(FILECREATED "19-DEC-73 00:16:44" PUP5)
(DEFINEQ
(@
[LAMBDA (C)
C])
(A:BEING:ORDER
[LAMBDA (B1 B2)
(LESSP (FAST:BEING:COMPLEX B1)
(FAST:BEING:COMPLEX B2])
(A:BEING:WHEN
[LAMBDA (BB)
(SETQ SUM 0)
[MAPC (GETP BB WHEN)
(FUNCTION (LAMBDA (W)
(COND
((EVAL (CAR W))
(SETQ SUM (PLUS SUM (EVAL (CADR W]
SUM])
(AD
[LAMBDA (L)
[MAPC L (FUNCTION (LAMBDA (Y)
(SET Y Y]
(SETQ PUP5FNS (SORT (APPEND PUP5FNS L)))
(SETQ PUP5FNS (INTERSECTION PUP5FNS PUP5FNS))
[MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (X)
(PUT X SPEC:WHY (QUOTE (QUOTE (NO SPECIAL REASON]
(MAKEFILE (QUOTE PUP5])
(ADD:BEING
[LAMBDA (B)
(SET B B)
(PUT B BEING T)
[MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (X)
(PRIN1 X)
(PRIN1 " ")
(PUT B X (READ]
(PRIN1
"*** FINISHED ***
SHOULD I MAKE A NEW FILE OF PUP? (T OR NIL)..... ")
(SETQ SET:OF:BEINGS (CONS B SET:OF:BEINGS))
(SEMI:COMPILE B)
(ADD:EFFECTS B)
(ADD:IDEN B)
(COND
((RATOM)
(AD (LIST B)))
(T (SETQ PUP5FNS (CONS B PUP5FNS))
T])
(ADD:EFFECTS
[LAMBDA (B)
(SETQ TEMPG (COPY (GETP B MAIN:EFFECTS)))
(SETQ EFFECTS:TABLE (APPEND EFFECTS:TABLE TEMPG))
(SORT EFFECTS:TABLE CAAR:ORDER])
(ADD:IDEN
[LAMBDA (B)
(SETQ TEMPG (COPY (GETP B IDEN)))
(SETQ IDEN:TABLE (APPEND IDEN:TABLE TEMPG))
(SORT IDEN:TABLE CAAR:ORDER])
(ASSERTIONS
[LAMBDA (TEMPA)
[MAPC ASSERT:LISTS (FUNCTION (LAMBDA (L)
(SETQ TEMPA (CONS (LIST L (EVAL L))
TEMPA]
TEMPA])
(ATTENTION:DEMONS
[LAMBDA NIL T])
(CAAR:ORDER
[LAMBDA (O1 O2)
(CAR:ORDER (CAR O1)
(CAR O2])
(CAR:ORDER
[LAMBDA (O1 O2)
(COND
(O1 (COND
[O2 (COND
((EQUAL (CAR O1)
(CAR O2))
(CAR:ORDER (CDR O1)
(CDR O2)))
((ATOM (CAR O1))
(ALPHORDER (CAR O1)
(CAR O2)))
((ATOM (CAR O2))
NIL)
(T (CAR:ORDER (CAR O1)
(CAR O2]
(T NIL)))
(T T])
(CHANGEB
[LAMBDA (B:NAME B:PART)
(SETQ TEMP (GETP B:NAME B:PART))
(EDITV TEMP)
(COND
((EQUAL B:PART MAIN:EFFECTS)
(REMOVE:EFFECTS B:NAME))
((EQUAL B:PART IDEN)
(REMOVE:IDEN B:NAME)))
(PUT B:NAME B:PART TEMP)
(COND
((MEMBER B:PART COMPILABLE:BEING:PARTS)
(SEMI:COMPILE B:NAME)))
(COND
((EQUAL B:PART MAIN:EFFECTS)
(ADD:EFFECTS B:NAME))
((EQUAL B:PART IDEN)
(ADD:IDEN B:NAME)))
T])
(CHANGEP
[LAMBDA (P)
(MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (B)
(SETQ X (GETP B P))
(PRINT B)
(COND
((ATOM X)
(PRIN1 "SORRY, PART IS NIL. NEW PART ....... ")
(SETQ X (READ)))
(T (EDITV X)))
(PUT B P X])
(CLASS
[NLAMBDA FORM
(MAPCAR FORM (FUNCTION (LAMBDA (F1)
(COND
((ATOM F1)
F1)
(T (EVAL F1])
(COLON:BACK
[LAMBDA (LL)
(SETQ MM (CAR LL))
[SETQ LL (MAPCAR (CDR LL)
(FUNCTION (LAMBDA (E)
(CONCAT ":" E]
(SETQ LL (CONS MM LL))
(PACK LL])
(COLON:BREAK
[LAMBDA (E)
(PROG (UP RP)
(SETQ UP (UNPACK E))
(SETQ BUFF NIL)
LL [COND
((NULL UP)
(SETQ RP (CONS (PACK BUFF)
RP))
(RETURN (REVERSE RP]
[COND
((MEMBER (CAR UP)
BREAKUP:LIST)
(SETQ RP (CONS (PACK BUFF)
RP))
(SETQ BUFF NIL))
(T (SETQ BUFF (NCONC1 BUFF (CAR UP]
(SETQ UP (CDR UP))
(GO LL])
(CSORT
[NLAMBDA X
(MAPC X (FUNCTION (LAMBDA (L)
(SET L (SORT (COPY (EVAL L])
(DEFERRAL:DEMON
[LAMBDA NIL
(MAPCAR UNDEFERRED:DECISION:LIST DEFER:DECISION])
(DIMENSION1
[LAMBDA (B)
(EVAL (CAR (GETP B COMPLEXITY:VECTOR])
(DIMENSION2
[LAMBDA (B)
(EVAL (CADR (GETP B COMPLEXITY:VECTOR])
(DIMENSION3
[LAMBDA (B)
(EVAL (CADDR (GETP B COMPLEXITY:VECTOR])
(DISK:DUMP
[LAMBDA (FILE STUFF)
(SETQ FILEVARS (MKATOM (CONCAT (MKSTRING FILE)
"VARS")))
(SET FILEVARS (QUOTE (EVERYTHING)))
(SETQ EVERYTHING STUFF)
(MAKEFILE FILE])
(DOT:PROD
[LAMBDA (L1 L2)
(COND
[L1 (PLUS (TIMES (CAR L1)
(CAR L2))
(DOT:PROD (CDR L1)
(CDR L2]
(T 0])
(DUMP:BEING
[LAMBDA (B)
(PRIN1 "************************* ")
(PRINT B)
[MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (X)
(COND
((SETQ X2 (GETP B X))
(PRINT X)
(PP X2)
(TERPRI]
(QUOTE FINISHED])
(ENCODE
[LAMBDA (FUNC FNAME FDESC F1 CODE FN:VALUE FINAL:CO:REQ BEING:FLAG
DEMON:FLAG)
(PROG1
(AND
(SETQ BEING:STACK (CONS ENCODE BEING:STACK))
(AND (MATCH (VECTOR (VECTOR FRAG1)
NAME ANY1 FRAG2 ANY2)
FUNC)
(SETQ FDESC FRAG1)
(SETQ FNAME ANY1)
(SETQ BNAME ANY2))
(PUSH:DEMONS NIL)
(PUT ENCODE SPEC:WHY BECAUSE)
[NOT (MEMBER NIL (MAPCAR USER:INTERRUPT:DEMONS (QUOTE APPLY*]
[SETQ FN:VALUE
(PROGN
(SETQ F1 (CADR FDESC))
[MAPC TYPE:OF:LIST (FUNCTION (LAMBDA (PC)
(COND
((MATCH (VECTOR F1 IS FRAG1)
PC)
(SETQ CODE FRAG1]
[COND
((NULL CODE)
(SETQ CODE (GETP F1 META:CODE]
[SETQ UNDEFINED:SECTION:LIST
(SETUNION UNDEFINED:SECTION:LIST
(SETDIFFERENCE (OUTNIL (FLATTEN CODE))
(APPEND WRITTEN:PROGRAMS:LIST
PUP5FNS
PRIMITIVE:PROGRAMS:LIST
PRIMITIVE:VARS:LIST
SET:OF:BEINGS
SET:OF:BEING:PARTS
PUP5VARS]
(EVAL
(LIST (QUOTE DEFINEQ)
(LIST FNAME
(APPEND (LIST (QUOTE LAMBDA)
(APPEND (GETP (CAR FDESC)
EXPLICIT:ARGS)
(GETP (CAR FDESC)
IMPLICIT:ARGS)))
CODE]
(NOT (MEMBER NIL (MAPCAR FINAL:CO:REQ SATISFY)))
(POP:DEMONS)
(SETQ BEING:FLAG T)
(SETQ BEING:STACK (CDR BEING:STACK))
FN:VALUE)
(COND
((NULL BEING:FLAG)
(SETQ BEING:STACK (CDR BEING:STACK))
(POP:DEMONS))
(DEMON:FLAG (POP:DEMONS])
(FAD
[LAMBDA (L)
[MAPC L (FUNCTION (LAMBDA (Y)
(SET Y Y]
[SETQ PUP5FNS (SORT (COPY (APPEND PUP5FNS L SET:OF:BEINGS]
(SETQ PUP5FNS (INTERSECTION PUP5FNS PUP5FNS))
(SETQ TEMP5 PUP5VARS)
[SETQ PUP5VARS (REVERSE (CONS (QUOTE (P (PRIN1
" FULL PUP FILE; USE MAD OR AD OR MAKEFILE FOR NEW VERSION ")))
(CDR (REVERSE PUP5VARS]
[MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (X)
(PUT X SPEC:WHY (QUOTE (QUOTE (NO SPECIAL REASON]
(MAKEFILE (QUOTE PUP5))
(SETQ PUP5VARS TEMP5)
(SETQ PUP5FNS (SETDIFFERENCE PUP5FNS SET:OF:BEINGS))
T])
(FAST:BEING:COMPLEX
[LAMBDA (B)
(DOT:PROD (QUOTE (.1 .6 .3))
(MAPCAR (GETP B COMPLEXITY:VECTOR)
EVAL])
(FILL:IN:UNDEFINED:SECTION
[LAMBDA (PROGRAM CHOICE FN:VALUE FINAL:CO:REQ BEING:FLAG DEMON:FLAG)
(PROG1
(AND (SETQ BEING:STACK (CONS FILL:IN:UNDEFINED:SECTION
BEING:STACK))
UNDEFINED:SECTION:LIST
(PUSH:DEMONS NIL)
(SETQ CHOICE (MINIMUM UNDEFINED:SECTION:LIST
FAST:BEING:COMPLEX))
[TRY:TO:SATISFY (QUOTE (VECTOR TYPE OF (VECTOR (@ CHOICE)
HAS BEEN
STUDIED]
(PUT FILL:IN:UNDEFINED:SECTION SPEC:WHY BECAUSE)
[NOT (MEMBER NIL (MAPCAR USER:INTERRUPT:DEMONS (QUOTE APPLY*]
(SETQ FN:VALUE
(COND
((SETQ PROGRAM (APPEND PROGRAM (ENCODE CHOICE)))
(SETQ UNDEFINED:SECTION:LIST (PULLOUT CHOICE
UNDEFINED:SECTION:LIST))
T)
(T [PUT CHOICE COMPLEXITY:VECTOR
(APPEND [LIST (DIMENSION1 CHOICE)
(PLUS .6 (TIMES .4 (DIMENSION2
CHOICE]
(CDDR (GETP CHOICE COMPLEXITY:VECTOR]
NIL)))
(NOT (MEMBER NIL (MAPCAR FINAL:CO:REQ SATISFY)))
(POP:DEMONS)
(SETQ BEING:FLAG T)
(SETQ BEING:STACK (CDR BEING:STACK))
FN:VALUE)
(COND
((NULL BEING:FLAG)
(SETQ BEING:STACK (CDR BEING:STACK))
(POP:DEMONS))
(DEMON:FLAG (POP:DEMONS])
(FIRST:FEW
[LAMBDA (L)
(SETQ N (PLUS 1 (IQUOTIENT (LENGTH L)
2)))
(REVERSE (NTH (REVERSE L)
N])
(FIRSTN
[LAMBDA (N L)
(PROG (TTT)
LLL (COND
((ZEROP N)
(RETURN TTT)))
(SETQ N (SUB1 N))
(SETQ TTT (NCONC1 TTT (CAR L)))
(SETQ L (CDR L))
(GO LLL])
(FLATTEN
[LAMBDA (L)
(COND
((ATOM L)
(LIST L))
(T (APPEND (FLATTEN (CAR L))
(FLATTEN (CDR L])
(FOREACH
[LAMBDA (X IN SET DO ACTION)
(PROG (RESULT)
START:HERE
(COND
((NULL SET)
(RETURN RESULT)))
(SET X (CAR SET))
(SETQ SET (CDR SET))
(SETQ RESULT (EVAL ACTION))
(GO START:HERE])
(FOREVER
[LAMBDA NIL NIL])
(FRINGE:OF:CONCIOUSNESS:DEMON
[LAMBDA NIL T])
(IDIOM:DEMON
[LAMBDA NIL T])
(INFERENCE:DEMONS
[LAMBDA NIL T])
(INITIALS
[LAMBDA (L)
(MAPCAR L (FUNCTION (LAMBDA (E)
(CAR (UNPACK E])
(INVECTOR
[LAMBDA (L)
(COND
((ATOM L)
L)
((EQUAL (CAR L)
VECTOR)
(MAPCAR L INVECTOR))
(T (CONS VECTOR (MAPCAR L INVECTOR])
(LUMP:ASSERTIONS
[LAMBDA (L TEMPL TEMPL2)
(SETQ TEMPL NIL)
(SETQ L (ASSERTIONS))
[MAPC L (FUNCTION (LAMBDA (L1)
(SETQ TEMPL (APPEND TEMPL (CADR L1]
(SETQ TEMPL2 (COPY TEMPL))
(SETQ TEMPL2 (INTERSECTION TEMPL2 TEMPL2))
(SORT TEMPL2])
(MAD
[LAMBDA (L)
[MAPC L (FUNCTION (LAMBDA (Y)
(SET Y Y]
(SETQ PUP5FNS (SORT (APPEND PUP5FNS L)))
(SETQ PUP5FNS (INTERSECTION PUP5FNS PUP5FNS))
(SETQ PUP5FNS (SETDIFFERENCE PUP5FNS SET:OF:BEINGS))
(SETQ TEMP5 PUP5VARS)
[SETQ PUP5VARS (REVERSE (CONS (QUOTE (P (MAPC SET:OF:BEINGS
SEMI:COMPILE)
(PRIN1
" MINI PUP FILE: USE FAD OR AD OR MAKEFILE FOR NEW VERSION ")))
(CDR (REVERSE PUP5VARS]
[MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (X)
(PUT X SPEC:WHY (QUOTE (QUOTE (NO SPECIAL REASON]
(MAKEFILE (QUOTE PUP5))
(SETQ PUP5VARS TEMP5)
(SETQ PUP5FNS (APPEND SET:OF:BEINGS PUP5FNS))
T])
(MAIN:WORDS
[LAMBDA (L)
(SETDIFFERENCE L MINOR:WORDS])
(MAKE:SPECIFIC
[LAMBDA (A)
(SETQ IS:SPECIFIC:LIST (CONS A IS:SPECIFIC:LIST])
(MATCH
[LAMBDA (A B LD)
[SETQ LD (ADD1 (DIFFERENCE (LENGTH B)
(LENGTH A]
(SETQ MATCH:RESULT T)
[COND
((MINUSP LD)
NIL)
(T (MAPC A (FUNCTION (LAMBDA (A1)
(COND
((MEMB A1 (QUOTE (ANY1 ANY2 ANY3)))
(SET A1 (CAR B))
(SETQ B (CDR B)))
[(MEMB A1 (QUOTE (FRAG1 FRAG2)))
(SET A1 (FIRSTN LD B))
(SETQ B (NTH B (ADD1 LD]
((EQUAL A1 (CAR B))
(SETQ B (CDR B)))
((LISTP A1)
[SETQ MATCH:RESULT (AND MATCH:RESULT
(MATCH A1 (CAR B]
(SETQ B (CDR B)))
(T (SETQ MATCH:RESULT NIL]
(AND (NULL B)
MATCH:RESULT])
(MINIMUM
[LAMBDA (L F MINV MIN TV ELE)
(SETQ MIN (CAR L))
(SETQ MINV (F MIN))
[MAPC (CDR L)
(FUNCTION (LAMBDA (ELE)
(COND
((LESSP (SETQ TV (F ELE))
MINV)
(SETQ MIN ELE)
(SETQ MINV TV]
MIN])
(MOVE:BEING
[LAMBDA (B:OLD B)
(SET B B)
(PUT B BEING T)
(SETQ SET:OF:BEINGS (CONS B SET:OF:BEINGS))
[MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (P)
(PUT B P (COPY (GETP B:OLD P]
(ADD:EFFECTS B)
(ADD:IDEN B)
(SETQ PUP5FNS (CONS B PUP5FNS))
(SEMI:COMPILE B])
(MULT:INTERSECTION
[LAMBDA (L)
(COND
[(CDDR L)
(SETINTERSECTION (CAR L)
(MULT:INTERSECTION (CDR L]
(T (SETINTERSECTION (CAR L)
(CADR L])
(NEW:IDEN
[LAMBDA NIL
(MAPC SET:OF:BEINGS
(FUNCTION (LAMBDA (B)
(PUT B IDEN
(LIST [LIST (QUOTE AND)
(LIST (QUOTE EQUAL)
(QUOTE (CAR LI))
B)
(LIST (QUOTE EQUAL)
(QUOTE (LENGTH (CDR LI)))
(LENGTH (GETP B EXPLICIT:ARGS]
(LIST (QUOTE LIST)
B
(LIST TRANSLATE (QUOTE (CADR LI])
(NEW:LEVEL
[LAMBDA (EXPERTISE)
(PROG NIL
L2 (COND
(EXPERTISE (PRIN1 "USER INTERRUPT LEVEL... "))
(T (PRIN1
"HELLO THERE. I AM READY TO START .
HOW OFTEN SHOULD I LET YOU INTERRRUPT ME, TO ASK ME ABOUT WHAT I'M
DOING? TYPE A DIGIT, AS EXPLAINED BELOW:
0 NEVER (ULTIMATE PRODUCTION-RUN MODE)
2 A COUPLE OF TIMES DURING THE COURSE OF WRITING A PROGRAM
4 DURING EACH PHASE OF WRITING A PROGRAM
6 DURING THE WRITING OF EACH NONTRIVIAL SUBFUNCTION OF A PROGRAM
8 DURING EACH PHASE OF WRITING EACH SUBFUNCTION OF A PROGRAM
10 EACH TIME A BEING TRANSFERS CONTROL (ULTIMATE DEBUG MODE)
OK, NOW TYPE A DIGIT... ")))
L [SETQ PERMANENT:USER:INTERRUPT:DEMONS
(SELECTQ (RATOM)
(0 (CLASS))
(2 (CLASS USER:INTERRUPT:AT:DEBUG
USER:INTERRUPT:AT:END))
(4 (CLASS USER:INTERRUPT:AT:PHASES))
(6 (CLASS USER:INTERRUPT:AT:PHASES
USER:INTERRUPT:AT:CODING))
(8 (CLASS USER:INTERRUPT:AT:PHASES
USER:INTERRUPT:AT:CODING
USER:INTERRUPT:AT:ADAPTING))
(10 (CLASS PERMIT:USER:INTERRUPT))
(AND (PRIN1
"
*** ERROR *** YOU MUST TYPE ONE EVEN INTEGER FROM 0 TO 10
TRY AGAIN:
")
(GO L]
(SETQ USER:INTERRUPT:DEMONS PERMANENT:USER:INTERRUPT:DEMONS])
(OUTNIL
[LAMBDA (S)
(COND
((ATOM S)
S)
((EQUAL (CAR S)
NIL)
(OUTNIL (CDR S)))
(T (CONS (OUTNIL (CAR S))
(OUTNIL (CDR S])
(OUTQUOTE
[LAMBDA (S)
(COND
((ATOM S)
S)
[(EQUAL (CAR S)
(QUOTE QUOTE))
(CONS TUPLE (OUTQUOTE (CADR S]
(T (CONS (OUTQUOTE (CAR S))
(OUTQUOTE (CDR S])
(OUTTUPLE
[LAMBDA (S)
(COND
((ATOM S)
S)
((EQUAL (CAR S)
TUPLE)
(OUTTUPLE (CDR S)))
(T (CONS (OUTTUPLE (CAR S))
(OUTTUPLE (CDR S])
(OUTVECTOR
[LAMBDA (S)
(COND
((ATOM S)
S)
((EQUAL (CAR S)
VECTOR)
(OUTVECTOR (CDR S)))
(T (CONS (OUTVECTOR (CAR S))
(OUTVECTOR (CDR S])
(PERMIT:USER:INTERRUPT
[LAMBDA NIL
(COND
(EXPERTISE (PRIN1 "INTERRUPT? "))
(T (PRIN1
"
DO YOU WISH TO INTERRUPT ME NOW, TO ASK ME ABOUT WHAT I'M DOING? ")))
(SELECTQ (RATOM)
(Y (PROCESS:USER:INTERRUPT))
(N T)
(PROGN (PRIN1 "
NO, NO. TYPE Y OR N ......... ")
(PERMIT:USER:INTERRUPT])
(POP:DEMONS
[LAMBDA NIL
(SETQ CURRENT:DEMONS (CAR DEMON:STACK))
(SETQ DEMON:STACK (CDR DEMON:STACK))
(SETQ DEMON:FLAG NIL)
T])
(PROCEDURE:INTERSECTION
[LAMBDA (P)
(SETQ P1 (CAAR P))
(COND
([MEMBER NIL (MAPCAR (CDR P)
(FUNCTION (LAMBDA (P2)
(EQUAL P1 P2]
NIL)
[(EQUAL P1 (QUOTE PROGN))
(CONS P1 (MULT:INTERSECTION (MAPCAR P (QUOTE CDR]
(T NIL])
(PROCEDURE:SUBSET
[LAMBDA (A1 A2)
(NOT (MEMBER NIL (MAPCAR (CDR A1)
(FUNCTION (LAMBDA (A3)
(MEMBER A3 A2])
(PROCESS:USER:INTERRUPT
[LAMBDA NIL
(PROG (RESPONSE BC BC1 BC2)
(COND
((NOT EXPERTISE)
[PRINT (APPEND (QUOTE (BEING IS))
(LIST (CAR BEING:STACK]
(PRIN1 " TYPE ? OR ")))
(SETQ BC (CAR BEING:STACK))
(SETQ BC1 NIL)
(SETQ BC2 (CDR BEING:STACK))
L (PRIN1 " REQUEST: ")
[SELECTQ
(SETQ RESPONSE (READ))
[? (PRIN1
" YOUR OPTIONS ARE AS FOLLOWS:
QUIT END THE INTERRUPT
BEING PRINT NAME OF CURRENT BEING
DEMONS PRINT SET OF DEMONS CURRENTLY ACTIVE
CONTROL:HISTORY PRINT LIST OF BEINGS IN CONTROL, THE PATH FROM THE
CURRENT BEING BACK TO THE BEGINNING OF THE PROGRAM
OLDER CONSIDER THE BEING WHICH CALLED THE CURRENT ONE
YOUNGER CONSIDER THE BEING WHICH THE CURRENT ONE CALLED
OLDEST CONSIDER THE FIRST BEING IN CONTROL
YOUNGEST CONSIDER THE LAST BEING IN CONTROL
")
(PRIN1
"SPEC:WHEN AN EVALUATED VERSION OF 'WHEN'
FAIL END THE INTERRUPT AND CAUSE CURRENT BEING TO FAIL
")
(PRIN1 "NEW:LEVEL CHANGE THE USER:INTERRUPT LEVEL
")
(PRIN1
"SPEC:WHY PRINT OUT THE SPECIFIC REASON(S) THAT THIS BEING WAS
CALLED. THIS DIFFERS FROM 'WHY' IN SENSE THAT SPEC:WHY IS
THE REASON GIVEN BY THE CALLER, WHERAS WHY IS THE REASON
STORED WITH THE CURRENT BEING PERMANENTLY.
")
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (Y)
(PRIN1 Y)
(PRIN1 " PRINT OUT ")
(PRIN1 Y)
(PRIN1 " WITH RESPECT TO CURRENT BEING
"]
(QUIT (COND
((NOT EXPERTISE)
(PRIN1 "
END OF INTERRUPT
")))
(RETURN T))
(FAIL (RETURN NIL))
[SPEC:WHEN [PRINT (MAPCAR (GETP BC WHEN)
(FUNCTION (LAMBDA (W)
(TUPLE (CAR W)
IS
(SETQ W2
(EVAL (CAR W)))
SO WE
(COND
(W2 (QUOTE DO))
(T (QUOTE DONT)))
ADD
IN THE WEIGHT
(CADR W) WHICH
IN THE CURRENT CASE IS
(EVAL (CADR W)) ;THE
EXPLANATION IS
(EVAL (CADDR W]
(PRINT (TUPLE THE FINAL WHEN VALUE IS THUS
(A:BEING:WHEN
BC]
(BEING (PRINT BC))
(CONTROL:HISTORY (PRIN1 BC1)
(PRIN1 " *** ")
(PRIN1 BC)
(PRIN1 " *** ")
(PRIN1 BC2)
(TERPRI))
(DEMONS (PRIN1 CURRENT:DEMONS)
(PRIN1 "
THE DEMON STACK IS ")
(PRINT DEMON:STACK))
(OLDER (SETQ BC1 (NCONC1 BC1 BC))
(SETQ BC (CAR BC2))
(SETQ BC2 (CDR BC2))
(PRINT BC))
(NEW:LEVEL (NEW:LEVEL))
(YOUNGER (SETQ BC2 (CONS BC BC2))
(SETQ BC (LAST BC1))
[SETQ BC1 (REVERSE (CDR (REVERSE BC1]
(PRINT BC))
(OLDEST (SETQ BC (LAST BEING:STACK))
[SETQ BC1 (REVERSE (CDR (REVERSE BEING:STACK]
(SETQ BC2 NIL)
(PRINT BC))
(YOUNGEST (SETQ BC (CAR BEING:STACK))
(SETQ BC2 (CDR BEING:STACK))
(SETQ BC1 NIL)
(PRINT BC))
(COND
[(MEMBER RESPONSE NON:EVAL:BEING:PARTS)
(PRINT (OUTVECTOR (OUTTUPLE (GETP BC RESPONSE]
[(MEMBER RESPONSE EVAL:BEING:PARTS)
(PRINT (OUTVECTOR (EVAL (GETP BC RESPONSE]
((NLSETQ (PRINT (EVAL RESPONSE)))
T)
(T (PRIN1
"
*** ERROR *** TYPE ? FOR ASSISTANCE **********
")
(GO L]
(GO L])
(PROGRAM:WRITING:DEMONS
[LAMBDA NIL T])
(PSYCHOLOGY:DEMON
[LAMBDA NIL T])
(PULLOUT
[LAMBDA (E L)
(COND
((ATOM L)
L)
((EQUAL E (CAR L))
(CDR L))
(T (CONS (CAR L)
(PULLOUT E (CDR L])
(PUSH:DEMONS
[LAMBDA (NEW:DEMONS)
(SETQ NEW:DEMO (SETDIFFERENCE NEW:DEMONS CURRENT:DEMONS))
(SETQ DEMON:STACK (CONS CURRENT:DEMONS DEMON:STACK))
(SETQ CURRENT:DEMONS (APPEND NEW:DEMO CURRENT:DEMONS))
(SETQ DEMON:FLAG T])
(REINVESTIGATION:DEMON
[LAMBDA NIL
(MAPCAR DEFERRED:DECISION:LIST (FUNCTION (LAMBDA (D)
(COND
((EVAL (CADDDR D))
(REINVESTIGATE:DECISION D))
(T NOT:TIME:YET])
(REMOVE:EFFECTS
[LAMBDA (B)
(SETQ TEMPG (COPY (GETP B MAIN:EFFECTS)))
(MAPC TEMPG (FUNCTION (LAMBDA (E)
(SETQ EFFECTS:TABLE (PULLOUT E EFFECTS:TABLE])
(REMOVE:IDEN
[LAMBDA (B)
(SETQ TEMPG (COPY (GETP B IDEN)))
(MAPC TEMPG (FUNCTION (LAMBDA (E)
(SETQ IDEN:TABLE (PULLOUT E IDEN:TABLE])
(RESOLUTION:DEMON
[LAMBDA NIL
(MAPCAR DEFERRED:DECISION:LIST (FUNCTION (LAMBDA (D)
(COND
((EVAL (CADR D))
(RESOLVE:DECISION D))
(T NOT:TIME:YET])
(SEMI:COMPILE
[LAMBDA (B)
(EVAL
(LIST
(QUOTE DEFINEQ)
(LIST
B
(APPEND
(QUOTE [LAMBDA])
[LIST (APPEND (GETP B EXPLICIT:ARGS)
(GETP B IMPLICIT:ARGS)
(QUOTE (FN:VALUE FINAL:CO:REQ BEING:FLAG
DEMON:FLAG]
(LIST
(LIST (QUOTE PROG1)
[APPEND (QUOTE (AND))
[LIST (LIST (QUOTE SETQ)
(QUOTE BEING:STACK)
(LIST (QUOTE CONS)
B
(QUOTE BEING:STACK]
(LIST (GETP B EXPLICIT:ARGS:CHECK))
[MAPCAR (GETP B PRE:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST SATISFY X]
(LIST (LIST (QUOTE PUSH:DEMONS)
(GETP B DEMONS)))
(GETP B COMMENTS)
[MAPCAR (GETP B CO:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST TRY:TO:SATISFY
(LIST (QUOTE QUOTE)
X]
(LIST (LIST (QUOTE PUT)
B SPEC:WHY (QUOTE BECAUSE)))
[QUOTE ((NOT (MEMBER NIL
(MAPCAR
USER:INTERRUPT:DEMONS
(QUOTE APPLY*]
(LIST (LIST (QUOTE SETQ)
(QUOTE FN:VALUE)
(GETP B META:CODE)))
[QUOTE ((NOT (MEMBER NIL (MAPCAR
FINAL:CO:REQ
SATISFY]
(QUOTE ((POP:DEMONS)))
[MAPCAR (GETP B POST:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST SATISFY X]
[QUOTE ((SETQ BEING:FLAG T)
(SETQ BEING:STACK (CDR BEING:STACK]
(COND
[(GETP B PREDICATE)
(QUOTE ((COND
(FN:VALUE)
(T FALSE]
(T (QUOTE (FN:VALUE]
(QUOTE (COND
((NULL BEING:FLAG)
(SETQ BEING:STACK (CDR BEING:STACK))
(POP:DEMONS))
(DEMON:FLAG (POP:DEMONS])
(SET:UP:EFFECTS:TABLE
[LAMBDA NIL
(SETQ E:TABLE NIL)
[MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (B)
(SETQ E:TABLE (APPEND E:TABLE (GETP B MAIN:EFFECTS]
(SETQ EFFECTS:TABLE (COPY E:TABLE))
(SORT EFFECTS:TABLE CAAR:ORDER)
(LENGTH EFFECTS:TABLE])
(SET:UP:IDEN:TABLE
[LAMBDA NIL
(SETQ E:TABLE FUNDAMENTAL:IDEN:TABLE)
[MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (B)
(SETQ E:TABLE (APPEND E:TABLE (GETP B IDEN]
(SETQ IDEN:TABLE (COPY E:TABLE))
(SORT IDEN:TABLE CAAR:ORDER)
(LENGTH IDEN:TABLE])
(SETDIFFERENCE
[LAMBDA (S1 S2)
(COND
((NULL S1)
NIL)
(T (APPEND [COND
((MEMBER (CAR S1)
S2)
NIL)
(T (LIST (CAR S1]
(SETDIFFERENCE (CDR S1)
S2])
(SETINTERSECTION
[LAMBDA (S1 S2)
(INTERSECTION S1 S2])
(SETUNION
[LAMBDA (S1 S2)
(SETQ S1 (APPEND S1 S2))
(INTERSECTION S1 S1])
(SINGLETON
[LAMBDA (S)
(NULL (CDR S])
(SIZE
[LAMBDA (STRUC)
(ADD1 (IQUOTIENT (COUNT STRUC)
2])
(SPECIFICITY:CHECK:DEMON
[LAMBDA (ANYTHING)
(MAPC (SETDIFFERENCE PUP:WANTS:LIST IS:SPECIFIC:LIST)
MAKE:SPECIFIC])
(START
[LAMBDA (EXPERTISE)
(PROG NIL
L1 (SETQ BEING:STACK NIL)
(SETQ BECAUSE (VECTOR))
(SETQ FORCE:TRANSLATE NIL)
(SETQ DEMON:STACK NIL)
(SETQ CURRENT:DEMONS NIL)
[MAPC ASSERT:LISTS (FUNCTION (LAMBDA (L)
(SET L NIL]
L2 (COND
(EXPERTISE (PRIN1 "USER INTERRUPT LEVEL... "))
(T (PRIN1
"HELLO THERE. I AM READY TO START .
HOW OFTEN SHOULD I LET YOU INTERRRUPT ME, TO ASK ME ABOUT WHAT I'M
DOING? TYPE A DIGIT, AS EXPLAINED BELOW:
0 NEVER (ULTIMATE PRODUCTION-RUN MODE)
2 A COUPLE OF TIMES DURING THE COURSE OF WRITING A PROGRAM
4 DURING EACH PHASE OF WRITING A PROGRAM
6 DURING THE WRITING OF EACH NONTRIVIAL SUBFUNCTION OF A PROGRAM
8 DURING EACH PHASE OF WRITING EACH SUBFUNCTION OF A PROGRAM
10 EACH TIME A BEING TRANSFERS CONTROL (ULTIMATE DEBUG MODE)
OK, NOW TYPE A DIGIT... ")))
L [SETQ PERMANENT:USER:INTERRUPT:DEMONS
(SELECTQ (RATOM)
(0 (CLASS))
(2 (CLASS USER:INTERRUPT:AT:DEBUG
USER:INTERRUPT:AT:END))
(4 (CLASS USER:INTERRUPT:AT:PHASES))
(6 (CLASS USER:INTERRUPT:AT:PHASES
USER:INTERRUPT:AT:CODING))
(8 (CLASS USER:INTERRUPT:AT:PHASES
USER:INTERRUPT:AT:CODING
USER:INTERRUPT:AT:ADAPTING))
(10 (CLASS PERMIT:USER:INTERRUPT))
(AND (PRIN1
"
*** ERROR *** YOU MUST TYPE ONE EVEN INTEGER FROM 0 TO 10
TRY AGAIN:
")
(GO L]
(SETQ USER:INTERRUPT:DEMONS PERMANENT:USER:INTERRUPT:DEMONS)
(SETQ USER:INTERRUPT:COPY:OF:PHASES PROGRAM:WRITING:PHASES)
L3 (SERVE)
L4 (COND
(EXPERTISE (PRIN1
"
FINISHED CURRENT SERVICE; WHAT SHOULD I DO? TYPE ONE OF:
1 EXIT FROM SYSTEM
2 CONTINUE SERVING, AS BEFORE
3 CONTINUE SERVING, BUT GET A NEW USER INTERRUPT LEVEL
4 REINITIALIZE SYSTEM AND START FROM BEGINNING AGAIN
OK, GO .......... "))
(T (PRIN1
"
FINISHED SERVICE. 1 EXIT; 2 CONTINUE; 3 NEW LEVEL; 4 START OVER ")))
(SELECTQ (RATOM)
(2 (GO L3))
(3 (GO L2))
(4 (GO L1))
(1 "EXITING SYSTEM")
(PRIN1 "NO, NO!!!!! ")
(GO L4])
(SUBSTITUTE
[LAMBDA (NEW FOR OLD IN LIST:STRUCTURE)
(SET LIST:STRUCTURE (SUBST NEW OLD (COPY (EVAL LIST:STRUCTURE])
(TRACE:COMPILE
[LAMBDA (B)
(EVAL
(LIST
(QUOTE DEFINEQ)
(LIST
B
(APPEND
(QUOTE [LAMBDA])
[LIST (APPEND (GETP B EXPLICIT:ARGS)
(GETP B IMPLICIT:ARGS)
(QUOTE (FN:VALUE FINAL:CO:REQ BEING:FLAG
DEMON:FLAG]
(LIST
(LIST
(QUOTE PROG1)
[APPEND
(QUOTE (AND))
[LIST (LIST (QUOTE PRINT)
(LIST (QUOTE SETQ)
(QUOTE BEING:STACK)
(LIST (QUOTE CONS)
B
(QUOTE BEING:STACK]
(LIST (LIST (QUOTE PRINT)
(GETP B EXPLICIT:ARGS:CHECK)))
[MAPCAR (GETP B PRE:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST (QUOTE PRINT)
(LIST SATISFY X]
[LIST (LIST (QUOTE PRINT)
(LIST (QUOTE PUSH:DEMONS)
(GETP B DEMONS]
[MAPCAR (GETP B CO:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST (QUOTE PRINT)
(LIST TRY:TO:SATISFY
(LIST (QUOTE QUOTE)
X]
(QUOTE ((PRINT "COMMENTS BEGINNING")))
(GETP B COMMENTS)
(QUOTE ((PRINT "COMMENTS ENDING")))
[LIST (LIST (QUOTE PRINT)
(LIST (QUOTE PUT)
B SPEC:WHY (QUOTE BECAUSE]
(QUOTE ((PRIN1 "NOT1 ")))
[QUOTE ((NOT (MEMBER NIL (PRINT (MAPCAR
USER:INTERRUPT:DEMONS
(QUOTE APPLY*]
[LIST (LIST (QUOTE PRINT)
(LIST (QUOTE SETQ)
(QUOTE FN:VALUE)
(GETP B META:CODE]
(QUOTE ((PRIN1 "NOT2 ")))
[QUOTE ((NOT (MEMBER NIL (PRINT (MAPCAR FINAL:CO:REQ
SATISFY]
[QUOTE ((PRINT (POP:DEMONS]
[MAPCAR (GETP B POST:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST (QUOTE PRINT)
(LIST SATISFY X]
[QUOTE ((SETQ BEING:FLAG T)
(SETQ BEING:STACK (CDR (PRINT BEING:STACK]
(COND
[(GETP B PREDICATE)
(QUOTE ((PRINT (COND
(FN:VALUE)
(T FALSE]
(T (QUOTE ((PRINT FN:VALUE]
[QUOTE (PRINT (TUPLE BEING:FLAG (@ BEING:FLAG)
DEMON:FLAG
(@ DEMON:FLAG]
(QUOTE (PRINT (COND
((NULL BEING:FLAG)
(SETQ BEING:STACK (CDR BEING:STACK))
(POP:DEMONS))
(DEMON:FLAG (POP:DEMONS])
(TRY:TO:SATISFY
[LAMBDA (SUBGOAL)
(COND
((SATISFY SUBGOAL)
T)
(T (SETQ FINAL:CO:REQ (CONS SUBGOAL FINAL:CO:REQ])
(TUPLE
[NLAMBDA FORM
(MAPCAR FORM (FUNCTION (LAMBDA (F1)
(COND
((ATOM F1)
F1)
(T (EVAL F1])
(USER:INTERRUPT:AT:ADAPTING
[LAMBDA (S:EXP)
(COND
((EQUAL B ADAPT:PRECONCEIVED:FUNCTION)
(SETQ USER:INTERRUPT:DEMONS (PULLOUT USER:INTERRUPT:AT:ADAPTING
USER:INTERRUPT:DEMONS))
(PERMIT:USER:INTERRUPT])
(USER:INTERRUPT:AT:CODING
[LAMBDA (S:EXP)
(COND
((EQUAL B ENCODE)
(SETQ USER:INTERRUPT:DEMONS (PULLOUT USER:INTERRUPT:AT:CODING
USER:INTERRUPT:DEMONS))
(PERMIT:USER:INTERRUPT])
(USER:INTERRUPT:AT:DEBUG
[LAMBDA (S:EXP)
(COND
((EQUAL B CLARIFY:IMPROBABLE:SITUATION)
(SETQ USER:INTERRUPT:DEMONS (PULLOUT USER:INTERRUPT:AT:DEBUG
USER:INTERRUPT:DEMONS))
(PERMIT:USER:INTERRUPT])
(USER:INTERRUPT:AT:END
[LAMBDA (S:EXP)
(COND
((EQUAL B OPTIMIZE)
(SETQ USER:INTERRUPT:DEMONS (PULLOUT USER:INTERRUPT:AT:END
USER:INTERRUPT:DEMONS))
(PERMIT:USER:INTERRUPT])
(USER:INTERRUPT:AT:PHASES
[LAMBDA (S:EXP)
(COND
((MEMBER B USER:INTERRUPT:COPY:OF:PHASES)
(SETQ USER:INTERRUPT:COPY:OF:PHASES (PULLOUT B
USER:INTERRUPT:COPY:OF:PHASES))
(PERMIT:USER:INTERRUPT])
(VECTOR
[NLAMBDA FORM
(CONS VECTOR (MAPCAR FORM (FUNCTION (LAMBDA (F1)
(COND
((ATOM F1)
F1)
(T (EVAL F1])
(WHEN:VALUE
[LAMBDA (B:CALL)
(SETQ EXP:A (GETP (CAR B:CALL)
EXPLICIT:ARGS))
[MAP2C EXP:A (CDR B:CALL)
(FUNCTION (LAMBDA (NEWARG OLDARG)
(SET NEWARG OLDARG]
(COND
((EVAL (GETP (CAR B:CALL)
EXPLICIT:ARGS:CHECK))
(A:BEING:WHEN (CAR B:CALL)))
(T -1000])
)
(LISPXPRINT (QUOTE PUP5FNS)
T)
(RPAQQ PUP5FNS
(@ A:BEING:ORDER A:BEING:WHEN AD ADD:BEING ADD:EFFECTS
ADD:IDEN ASSERTIONS ATTENTION:DEMONS CAAR:ORDER CAR:ORDER
CHANGEB CHANGEP CLASS COLON:BACK COLON:BREAK CSORT
DEFERRAL:DEMON DIMENSION1 DIMENSION2 DIMENSION3 DISK:DUMP
DOT:PROD DUMP:BEING ENCODE FAD FAST:BEING:COMPLEX
FILL:IN:UNDEFINED:SECTION FIRST:FEW FIRSTN FLATTEN FOREACH
FOREVER FRINGE:OF:CONCIOUSNESS:DEMON IDIOM:DEMON
INFERENCE:DEMONS INITIALS INVECTOR LUMP:ASSERTIONS MAD
MAIN:WORDS MAKE:SPECIFIC MATCH MINIMUM MOVE:BEING
MULT:INTERSECTION NEW:IDEN NEW:LEVEL OUTNIL OUTQUOTE
OUTTUPLE OUTVECTOR PERMIT:USER:INTERRUPT POP:DEMONS
PROCEDURE:INTERSECTION PROCEDURE:SUBSET
PROCESS:USER:INTERRUPT PROGRAM:WRITING:DEMONS
PSYCHOLOGY:DEMON PULLOUT PUSH:DEMONS REINVESTIGATION:DEMON
REMOVE:EFFECTS REMOVE:IDEN RESOLUTION:DEMON SEMI:COMPILE
SET:UP:EFFECTS:TABLE SET:UP:IDEN:TABLE SETDIFFERENCE
SETINTERSECTION SETUNION SINGLETON SIZE
SPECIFICITY:CHECK:DEMON START SUBSTITUTE TRACE:COMPILE
TRY:TO:SATISFY TUPLE USER:INTERRUPT:AT:ADAPTING
USER:INTERRUPT:AT:CODING USER:INTERRUPT:AT:DEBUG
USER:INTERRUPT:AT:END USER:INTERRUPT:AT:PHASES VECTOR
WHEN:VALUE))
(LISPXPRINT (QUOTE PUP5VARS)
T)
[RPAQQ PUP5VARS
(ALTERNATIVES:DEFER:DECISION:KNOWLEDGE
APPLIED:SO:AS:TO:KEEP ASSERT:LISTS BEING BREAKUP:LIST UNTIL
FUNDAMENTAL:IDEN:TABLE SINCE FOREVER PRIMITIVE:PROGRAMS:LIST
PRIMITIVE:VARS:LIST Y N NOT:TIME:YET CALL
COMPILABLE:BEING:PARTS EFFECTS:TABLE EVAL PARTS
EVAL:BEING:PARTS FALSE IDEN:TABLE INFERIOR MINOR:WORDS NAME
NON:EVAL:BEING:PARTS NON:EXECUTABLE PERMANENT:KNOWN:NAMES
PROGRAM:WRITING:PHASES SET:OF:BEING:PARTS SET:OF:BEINGS
SUPERIOR (COMS * (LIST (APPEND (QUOTE (PROP ALL))
SET:OF:BEINGS)))
[P (MAPC (APPEND PUP5FNS SET:OF:BEINGS SET:OF:BEING:PARTS)
(FUNCTION (LAMBDA (V)
(SET V V]
(P (MAPC SET:OF:BEINGS SEMI:COMPILE)
(PRIN1
" MINI PUP FILE: USE FAD OR AD OR MAKEFILE FOR NEW VERSION "]
[RPAQQ ALTERNATIVES:DEFER:DECISION:KNOWLEDGE
((COND ([AND [NOT (MEMBER NIL (MAPCAR (SETQ C (CADR DEC))
(FUNCTION
(LAMBDA (D)
(GETP D BEING]
(SETQ PROC (PROCEDURE:INTERSECTION
(MAPCAR C (FUNCTION (LAMBDA (D)
(GETP D
META:CODE]
(SETQ TYPE:OF:LIST (CONS (VECTOR (LAST DEC)
IS
(VECTOR TEMPORARILY
(@ PROC)))
TYPE:OF:LIST))
(RETURN (TUPLE PROCEDURE:SUBSET (@ PROC)
ABLE:PUP:LIST)))
(T T]
(RPAQQ APPLIED:SO:AS:TO:KEEP APPLIED:SO:AS:TO:KEEP)
(RPAQQ ASSERT:LISTS
(ABLE:PUP:LIST ABLE:USER:LIST ATTEMPTING:ANYTHING:LIST
ATTEMPTING:SOMETHING:LIST AWARE:PUP:LIST
AWARE:USER:LIST EXECUTABLE:INFO:LIST
IS:SPECIFIC:LIST RESOLVED:DECISION:LIST
KNOWN:NAMES NAMED:EXPRESSION:LIST NEW:INFO:LIST
PLAUSIBLE:NAMES:LIST PUP:SATISFIED:LIST
PUP:STUDIED:LIST PUP:WANTED:LIST PUP:WANTS:LIST
READ:USER:LIST RELEVANT:INFO:LIST
TRANSLATED:INFO:LIST TRANSLATED:PAIR:LIST
TYPE:OF:LIST UNDEFERRED:DECISION:LIST
USABLE:INFO:LIST USER:WANTS:LIST
WRITTEN:PROGRAMS:LIST DEFERRED:DECISION:LIST
UNDEFINED:SECTION:LIST))
(RPAQQ BEING BEING)
(RPAQQ BREAKUP:LIST (: ; %. , - ?))
(RPAQQ UNTIL UNTIL)
[RPAQQ FUNDAMENTAL:IDEN:TABLE
(((MEMBER (CAR LI)
(QUOTE (AND OR NOT EQUAL LESSP GREATERP MINUSP)))
(APPEND (VECTOR (CAR LI))
(MAPCAR (CDR LI)
TRANSLATE)))
((EQUAL (CAR LI)
(QUOTE COND))
(APPEND (VECTOR COND)
(MAPCAR (CDR LI)
(FUNCTION (LAMBDA (L)
(MAPCAR L TRANSLATE]
(RPAQQ SINCE SINCE)
(RPAQQ FOREVER FOREVER)
(RPAQQ PRIMITIVE:PROGRAMS:LIST
(AND OR NOT COND MAPC MAPCAR LAMBDA FUNCTION PLUS TIMES LIST
APPEND CONS CAR CDR CADR CADDR CADDDR CADAR PLUS MINUS
MINUSP TIMES QUOTIENT ADD1 SUB1 SET SETQ NULL QUOTE EVAL
LESSP EQUAL))
(RPAQQ PRIMITIVE:VARS:LIST
(T NIL 0 1 2 3 4 5 6 7 8 9 10 -1 -2 -3))
(RPAQQ Y NOBIND)
(RPAQQ N 2)
(RPAQQ NOT:TIME:YET NOT:TIME:YET)
(RPAQQ CALL CALL)
(RPAQQ COMPILABLE:BEING:PARTS
(META:CODE COMMENTS PRE:REQUISITES CO:REQUISITES
POST:REQUISITES EXPLICIT:ARGS EXPLICIT:ARGS:CHECK
IMPLICIT:ARGS DEMONS))
[RPAQQ EFFECTS:TABLE (((VECTOR ABLE PUP ANY1)
(VECTOR WRITE:PROGRAM (@ ANY1)))
((VECTOR ABLE PUP (VECTOR LEARN CONCEPTS))
(VECTOR CONCEPT:FORMATION))
((VECTOR ABLE PUP (VECTOR REFER ANY1 AS ANY2))
(VECTOR GET:NAME (@ ANY1)
(@ ANY2)))
((VECTOR ABLE USER ANY1)
(VECTOR WRITE:PROGRAM (@ ANY1)))
((VECTOR ABLE USER (VECTOR REFER ANY1 AS ANY2))
(VECTOR GET:NAME (@ ANY1)
(@ ANY2)))
((VECTOR ATTEMPTING ANYTHING)
(VECTOR SERVE))
((VECTOR ATTEMPTING SOMETHING)
(VECTOR SERVE))
[(VECTOR AWARE ANY1 (DELAYABLE ANY2))
(VECTOR WHEN:NEXT (VECTOR (@ ANY1)
(CADR ANY2)
(CADDR ANY2]
((VECTOR AWARE PUP (VECTOR IMPLICATIONS ANY1))
(VECTOR ANALYZE:IMPLICATIONS (@ ANY1)))
((VECTOR AWARE USER ANY1)
(VECTOR MESSAGE (@ ANY1)))
((VECTOR DEFERRED DECISION ANY1)
(VECTOR DEFER:DECISION (@ ANY1)))
((VECTOR NAMED EXPRESSION ANY1 ANY2)
(VECTOR GET:NAME (@ ANY1)
(@ ANY2)))
((VECTOR NEW INFO ANY1)
(VECTOR GET:NEW:INFORMATION (TUPLE QUOTE ANY1)))
((VECTOR NEW INFO ANY1)
(VECTOR OBTAIN:USABLE:INFORMATION (@ ANY1)))
((VECTOR PLAUSIBLE NAMES (VECTOR FOR ANY1 HAVE BEEN STUDIED))
(VECTOR PROPOSE:PLAUSIBLE:NAMES (@ ANY1)))
((VECTOR PUP SATISFIED ANY1)
(VECTOR SATISFY (@ ANY1)))
((VECTOR PUP STUDIED (VECTOR PLAUSIBLE NAMES FOR ANY1))
(VECTOR PROPOSE:PLAUSIBLE:NAMES (@ ANY1)))
((VECTOR PUP STUDIED (VECTOR TYPE OF ANY1))
(VECTOR STUDY:TYPE (@ ANY1)))
((VECTOR READ USER ANY1)
(VECTOR MESSAGE (@ ANY1)))
((VECTOR RELEVANT INFO ANY1)
(VECTOR EXTRACT:RELEVANT:SUBSET (@ ANY1)))
[(VECTOR RESOLVED DECISION ANY1)
(VECTOR RESOLVE:DECISION (VECTOR (VECTOR BECAUSE OF DIRECT
COMMAND)
(@ D]
[(VECTOR RESOLVED DECISION ANY1)
(VECTOR RESOLVE:DECISION (VECTOR (VECTOR BECAUSE OF DIRECT
COMMAND)
(@ D]
((VECTOR TRANSLATED INFO ANY1)
(VECTOR TRANSLATE (@ ANY1)))
((VECTOR TYPE OF (VECTOR ANY1 HAS BEEN STUDIED))
(VECTOR STUDY:TYPE (@ ANY1)))
((VECTOR USABLE INFO ANY1)
(VECTOR OBTAIN:USABLE:INFORMATION (@ ANY1)))
((VECTOR USABLE INFO (VECTOR NEW INFO ANY1))
(VECTOR TRANSLATE (@ ANY1)))
((VECTOR WRITTEN PROGRAMS ANY1)
(VECTOR WRITE:PROGRAM (@ ANY1]
(RPAQQ EVAL EVAL)
(RPAQQ PARTS PARTS)
(RPAQQ EVAL:BEING:PARTS (WHAT HOW WHY AFFECTS SPEC:WHY PREDICATE))
(RPAQQ FALSE FALSE)
[RPAQQ IDEN:TABLE (((AND (EQUAL (CAR LI)
ANALYZE:IMPLICATIONS)
(EQUAL (LENGTH (CDR LI))
1))
(VECTOR ANALYZE:IMPLICATIONS (TRANSLATE (CADR LI)
T)))
((AND (EQUAL (CAR LI)
BETTER)
(EQUAL (LENGTH LI)
3))
(VECTOR BETTER (TRANSLATE (CADR LI)
T)
(TRANSLATE (CADDR LI)
T)))
((AND (EQUAL (CAR LI)
CALL)
(EQUAL (LENGTH LI)
3))
(VECTOR GET:NAME (CADR LI)
(CADDR LI)))
[(AND (EQUAL (CAR LI)
CHOOSE:FROM)
(EQUAL (LENGTH LI)
2))
(VECTOR CHOOSE:FROM (MAPCAR (CADR LI)
(FUNCTION (LAMBDA (Y)
(TRANSLATE
Y T]
((AND (EQUAL (CAR LI)
DEFER:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR DEFER:DECISION (CADR LI)))
((AND (EQUAL (CAR LI)
EXTRACT:RELEVANT:SUBSET)
(EQUAL (LENGTH LI)
2))
(VECTOR EXTRACT:RELEVANT:SUBSET (TRANSLATE (CADR LI)
T)))
((AND (EQUAL (CAR LI)
GET:NEW:INFORMATION)
(EQUAL (LENGTH LI)
2))
(VECTOR GET:NEW:INFORMATION (CADR LI)))
((AND (EQUAL (CAR LI)
MESSAGE)
(EQUAL (LENGTH LI)
2))
(VECTOR MESSAGE (CADR LI)))
((AND (EQUAL (CAR LI)
NAME)
(EQUAL (LENGTH LI)
3))
(VECTOR GET:NAME (CADR LI)
(CADDR LI)))
((AND (EQUAL (CAR LI)
OBTAIN:USABLE:INFORMATION)
(EQUAL (LENGTH LI)
2))
(VECTOR OBTAIN:USABLE:INFORMATION (CADR LI)))
((AND (EQUAL (CAR LI)
PROPOSE:PLAUSIBLE:NAMES)
(EQUAL (LENGTH LI)
2))
(VECTOR PROPOSE:PLAUSIBLE:NAMES (CADR LI)))
((AND (EQUAL (CAR LI)
RESOLVE:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR RESOLVE:DECISION (CADR LI)))
((AND (EQUAL (CAR LI)
RESOLVE:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR RESOLVE:DECISION (CADR LI)))
((AND (EQUAL (CAR LI)
SATISFY)
(EQUAL (LENGTH LI)
2))
(VECTOR SATISFY (TRANSLATE (CADR LI)
T)))
((AND (EQUAL (CAR LI)
TRANSLATE T)
(EQUAL (LENGTH LI)
2))
(VECTOR TRANSLATE (CADR LI)))
((AND (EQUAL (CAR LI)
UTILIZE)
(EQUAL (LENGTH LI)
4))
(VECTOR UTILIZE (TRANSLATE (CADR LI))
(CADDR LI)
(CADDDR LI)))
((AND (EQUAL (CAR LI)
WRITE:PROGRAM)
(EQUAL (LENGTH LI)
2))
(VECTOR WRITE:PROGRAM (TRANSLATE (CADR LI)
T)))
((EQUAL LI (QUOTE (FILL:IN:UNDEFINED:SECTION)))
(VECTOR FILL:IN:UNDEFINED:SECTION (CADR LI)))
((EQUAL LI (QUOTE (SERVE)))
(VECTOR SERVE))
((EQUAL (CAR LI)
FILL:IN:UNDEFINED:SECTION)
(VECTOR FILL:IN:UNDEFINED:SECTION (CADR LI)))
((MATCH (QUOTE (DEFER THE DECISION ANY1))
LI)
(VECTOR DEFER:DECISION (@ ANY1)))
((MATCH (QUOTE (ENCODE ANY1))
LI)
(CONS VECTOR LI))
((MATCH (QUOTE (PROPOSE PLAUSIBLE NAMES FOR ANY1))
LI)
(VECTOR PROPOSE:PLAUSIBLE:NAMES (CADR LI)))
[(MATCH (QUOTE (RESOLVE THE DECISION ANY1))
LI)
(VECTOR RESOLVE:DECISION (VECTOR (VECTOR BECAUSE OF DIRECT
COMMAND)
(@ ANY1]
[(MATCH (QUOTE (RESOLVE THE DECISION ANY1))
LI)
(VECTOR RESOLVE:DECISION (VECTOR (VECTOR BECAUSE OF DIRECT
COMMAND)
(@ ANY1]
((MATCH (QUOTE (STUDY:TYPE ANY1))
LI)
(VECTOR STUDY:TYPE (CADR LI)))
((MATCH (QUOTE (THE NEXT TIME (VECTOR ANY1 ANY2 ANY3)))
LI)
(VECTOR WHEN:NEXT (CADDDR LI)))
((MATCH (QUOTE (WHEN:NEXT (VECTOR ANY1 ANY2 ANY3)))
LI)
(VECTOR WHEN:NEXT (CADR LI)))
((MATCH (QUOTE (WRITE A PROGRAM WHICH DOES FRAG1))
LI)
(VECTOR WRITE:PROGRAM (TRANSLATE (INVECTOR FRAG1)
T)))
([MEMBER LI (QUOTE ((CONCEPT FORMATION)
(CONCEPT:FORMATION)
(CONCEPT LEARNING)
(FORM CONCEPTS)
(LEARN CONCEPTS)
(LEARNS CONCEPTS)
(FORMS CONCEPTS]
(VECTOR CONCEPT:FORMATION]
(RPAQQ INFERIOR INFERIOR)
(RPAQQ MINOR:WORDS
(A AT DO DOES FOR IN PROGRAM THE TO WHICH WHILE WRITE))
(RPAQQ NAME NAME)
(RPAQQ NON:EVAL:BEING:PARTS
(IDEN IMPLICIT:ARGS EXPLICIT:ARGS WHEN META:CODE COMMENTS
PRE:REQUISITES CO:REQUISITES POST:REQUISITES
EXPLICIT:ARGS:CHECK DEMONS MAIN:EFFECTS MINOR:EFFECTS
COMPLEXITY:VECTOR GENERALIZATIONS SPECIALIZATIONS
ALTERNATIVES))
(RPAQQ NON:EXECUTABLE NON:EXECUTABLE)
(RPAQQ PERMANENT:KNOWN:NAMES NIL)
(RPAQQ PROGRAM:WRITING:PHASES (OBTAIN:USABLE:INFORMATION
USE:INFORMATION
FILL:IN:UNDEFINED:SECTION
ADAPT:PRECONCIVED:FUNCTION
CLARIFY:IMPROBABLE:SITUATION
FIX:INCORRECT:PIECE
OPTIMIZE))
(RPAQQ SET:OF:BEING:PARTS
(IDEN IMPLICIT:ARGS EXPLICIT:ARGS EXPLICIT:ARGS:CHECK WHAT HOW
WHY SPEC:WHY MAIN:EFFECTS MINOR:EFFECTS WHEN META:CODE
COMMENTS PRE:REQUISITES CO:REQUISITES POST:REQUISITES
DEMONS AFFECTS COMPLEXITY:VECTOR GENERALIZATIONS
SPECIALIZATIONS ALTERNATIVES PREDICATE))
(RPAQQ SET:OF:BEINGS
(ENCODE FILL:IN:UNDEFINED:SECTION UTILIZE ANALYZE:IMPLICATIONS
BETTER CHOOSE:FROM CONCEPT:FORMATION DEFER:DECISION
EXTRACT:RELEVANT:SUBSET GET:NAME GET:NEW:INFORMATION
MESSAGE OBTAIN:USABLE:INFORMATION
PROPOSE:PLAUSIBLE:NAMES REINVESTIGATE:DECISION
RESOLVE:DECISION SATISFY SERVE STUDY:TYPE TRANSLATE
WHEN:NEXT WRITE:PROGRAM))
(RPAQQ SUPERIOR SUPERIOR)
(PUTPROPS ENCODE BEING T
IDEN (((MATCH (QUOTE (ENCODE ANY1))
LI)
(CONS VECTOR LI)))
IMPLICIT:ARGS (FNAME FDESC F1 CODE)
EXPLICIT:ARGS (FUNC)
EXPLICIT:ARGS:CHECK (AND (MATCH (VECTOR
(VECTOR FRAG1)
NAME ANY1 FRAG2
ANY2)
FUNC)
(SETQ FDESC FRAG1)
(SETQ FNAME ANY1)
(SETQ BNAME ANY2))
WHAT (VECTOR ENCODE A FUNCTION NAMED (@ FNAME)
TO ACCOMPLISH (@ BNAME)
BY USING, AMONG OTHER FACTS,
(@ FDESC))
HOW (VECTOR DEFINE (@ FNAME)
USING
(@ FDESC))
WHY (VECTOR (@ FNAME)
IS CURRENTLY UNDEFINED)
SPEC:WHY (QUOTE (NO SPECIAL REASON))
MAIN:EFFECTS NIL
MINOR:EFFECTS NIL
WHEN NIL
META:CODE [PROGN
(SETQ F1 (CADR FDESC))
[MAPC TYPE:OF:LIST
(FUNCTION
(LAMBDA (PC)
(COND
((MATCH (VECTOR F1 IS
FRAG1)
PC)
(SETQ CODE FRAG1]
[COND ((NULL CODE)
(SETQ CODE (GETP F1 META:CODE]
[SETQ UNDEFINED:SECTION:LIST
(SETUNION
UNDEFINED:SECTION:LIST
(SETDIFFERENCE
(OUTNIL (FLATTEN CODE))
(APPEND WRITTEN:PROGRAMS:LIST
PUP5FNS
PRIMITIVE:PROGRAMS:LIST
PRIMITIVE:VARS:LIST
SET:OF:BEINGS
SET:OF:BEING:PARTS
PUP5VARS]
(EVAL
(LIST
(QUOTE DEFINEQ)
(LIST
FNAME
(APPEND
(LIST
(QUOTE LAMBDA)
(APPEND (GETP (CAR FDESC)
EXPLICIT:ARGS)
(GETP (CAR FDESC)
IMPLICIT:ARGS)))
CODE]
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
DEMONS NIL
AFFECTS NIL
COMPLEXITY:VECTOR (.5 .5 .5 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL
PREDICATE NIL)
(PUTPROPS FILL:IN:UNDEFINED:SECTION BEING T
IDEN [((EQUAL (CAR LI)
FILL:IN:UNDEFINED:SECTION)
(VECTOR
FILL:IN:UNDEFINED:SECTION
(CADR LI]
IMPLICIT:ARGS (CHOICE)
EXPLICIT:ARGS (PROGRAM)
EXPLICIT:ARGS:CHECK
UNDEFINED:SECTION:LIST
WHAT (VECTOR FILL IN AN UNDEFINED
SECTION OF CODE AND
ADD IT TO THE
PROGRAM
(@ PROGRAM))
HOW (VECTOR CHOOSE THE SIMPLEST
UNDEFINED PIECE AND
ENCODE IT)
WHY (VECTOR BECAUSE ALL PIECES OF
CODE MUST BE DEFINED
OR THE PROGRAM WONT
RUN)
SPEC:WHY (QUOTE (NO SPECIAL
REASON))
MAIN:EFFECTS NIL
MINOR:EFFECTS NIL
WHEN ((UNDEFINED:SECTION:LIST
80
(TUPLE BECAUSE
UNDEFINED:SECTION:LIST
CONTAINS PIECES OF
CODE AS YET
UNDEFINED))
((NULL
UNDEFINED:SECTION:LIST)
-1000
(TUPLE BECAUSE NO PIECES
OF CODE ARE KNOWN
AND YET NOT YET
DEFINED)))
META:CODE (COND
((SETQ
PROGRAM
(APPEND
PROGRAM
(ENCODE CHOICE)))
(SETQ
UNDEFINED:SECTION:LIST
(PULLOUT
CHOICE
UNDEFINED:SECTION:LIST))
T)
(T
[PUT
CHOICE
COMPLEXITY:VECTOR
(APPEND
[LIST
(DIMENSION1
CHOICE)
(PLUS
.6
(TIMES
.4
(
DIMENSION2 CHOICE]
(CDDR
(GETP CHOICE
COMPLEXITY:VECTOR]
NIL))
COMMENTS ((SETQ CHOICE
(MINIMUM
UNDEFINED:SECTION:LIST
FAST:BEING:COMPLEX)))
PRE:REQUISITES NIL
CO:REQUISITES ((VECTOR
TYPE OF
(VECTOR
(@ CHOICE)
HAS BEEN
STUDIED)))
POST:REQUISITES NIL
DEMONS NIL
AFFECTS (QUOTE ((ENCODE CALLED)))
COMPLEXITY:VECTOR (.5 .5 .5 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL
PREDICATE NIL)
(PUTPROPS UTILIZE BEING T
IDEN [((AND (EQUAL (CAR LI)
UTILIZE)
(EQUAL (LENGTH LI)
4))
(VECTOR UTILIZE (TRANSLATE (CADR LI))
(CADDR LI)
(CADDDR LI]
IMPLICIT:ARGS (KNOW:LIST DEC)
EXPLICIT:ARGS (KNOW:NAME APPLIED:SO:AS:TO:KEEP
INVARIANT)
EXPLICIT:ARGS:CHECK (AND
(EQUAL (CAR INVARIANT)
VECTOR)
(MEMBER (CADR INVARIANT)
(QUOTE (RELEVANT
IRRELEVANT)))
(ATOM KNOW:NAME)
(LISTP (EVAL KNOW:NAME)))
WHAT (TUPLE USE THE LIST (@ KNOW:LIST)
OF INFORMATION TO DECIDE THE TURNING
POINT OF THE TRUTH OF THE PREDICATE
(@ INVARIANT))
HOW (TUPLE SEARCH THROUGH (@ KNOW:LIST)
FOR APPLICABLE RULES)
WHY (TUPLE SO PUP KNOWS WHEN (@ INVARIANT)
CHANGES TRUTH VALUE)
SPEC:WHY (QUOTE (NO SPECIAL REASON))
MAIN:EFFECTS NIL
MINOR:EFFECTS NIL
WHEN NIL
META:CODE [PROG
(AF)
(COND
[(MATCH (VECTOR PUP REINVESTIGATE
FRAG1)
INVARIANT)
(COND
((SETQ AF (CADR (MEMBER WHEN DEC)))
(RETURN (EVAL AF)))
[(SETQ AF (CADR (MEMBER AFFECTS
DEC)))
(MAPC
KNOW:LIST
(FUNCTION
(LAMBDA
(K)
(COND
((MATCH
(VECTOR AFFECTS
(@ AF)
ANY1)
K)
(RETURN (EVAL ANY1]
[(MAPC KNOW:LIST
(FUNCTION
(LAMBDA
(K)
(COND ((SETQ
AF
(EVAL K))
(RETURN AF]
(T (RETURN NIL]
(T (RETURN NIL]
COMMENTS ((SETQ KNOW:LIST (EVAL KNOW:NAME)))
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
DEMONS NIL
AFFECTS NIL
COMPLEXITY:VECTOR (.5 .5 .5 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL
PREDICATE NIL)
(PUTPROPS ANALYZE:IMPLICATIONS IDEN [((AND
(EQUAL (CAR LI)
ANALYZE:IMPLICATIONS)
(EQUAL (LENGTH (CDR LI))
1))
(VECTOR ANALYZE:IMPLICATIONS
(TRANSLATE
(CADR LI)
T]
BEING T
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (NEW:INFO)
WHAT (TUPLE ANALYZE THE IMPLICATIONS
OF SOME OF THE NEW
INFORMATION (@ NEW:INFO))
HOW (TUPLE BY LOCALIZING THE EFFECTS
OF THE NEW INFO AND
STUDYING THEM)
WHY (TUPLE TO IMPROVE THE
UNDERSTANDING THAT PUP HAS
OF THE NEW INFORMATION
(@ NEW:INFO))
SPEC:WHY (QUOTE (NO SPECIAL REASON))
WHEN (((SETQ ANY1 (CAR
USABLE:INFO:LIST))
-60
(TUPLE BECAUSE WE SHOULD USE
(@ ANY1)
BEFORE WORRYING ABOUT
(@ NEW:INFO)))
(T (DIFFERENCE 50 (SIZE NEW:INFO)
)
(TUPLE BECAUSE THE SIZE OF
THE NEW INFORMATION
(@ NEW:INFO)
AFFECTS HOW EASILY AND
FRUITFULLY AN ANALYSIS
OF IT WILL BE)))
META:CODE (PROGN (LOCATE:AFFECTED:AREA
NEW:INFO)
(PREDICT:AFFECT
NEW:INFO)
(EVALUATE:AFFECT
NEW:INFO))
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK (MEMBER NEW:INFO
RELEVANT:INFO:LIST)
DEMONS NIL
MAIN:EFFECTS [((VECTOR AWARE PUP
(VECTOR
IMPLICATIONS
ANY1))
(VECTOR
ANALYZE:IMPLICATIONS
(@ ANY1]
MINOR:EFFECTS NIL
AFFECTS (QUOTE ((LOCATE AFFECTED:AREA
CALLED)
(PREDICT:AFFECT CALLED)
(EVALUATE:AFFECT
CALLED)))
COMPLEXITY:VECTOR (.4 .7 .7 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL)
(PUTPROPS BETTER IDEN [((AND (EQUAL (CAR LI)
BETTER)
(EQUAL (LENGTH LI)
3))
(VECTOR BETTER (TRANSLATE (CADR LI)
T)
(TRANSLATE (CADDR LI)
T]
BEING T
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (B1 B2)
WHAT (TUPLE DECIDE WHICH OF (@ B1)
(@ B2)
IS MORE A PROPOS TO TRY)
HOW (TUPLE COMPARE THE WHEN PARTS OF
(@ (CAR B1))
AND
(@ (CAR B2))
AND, IF NECESSARY, COMPARE THEIR
COMPLEXITY VECTORS)
WHY (TUPLE PUP CAN ONLY TRY AT MOST ONE OF
(@ (CAR B1))
AND
(@ (CAR B2))
AT A TIME)
SPEC:WHY (QUOTE (NO SPECIAL REASON))
WHEN NIL
META:CODE (PROGN
(SETQ B1NEW B1)
(SETQ B2NEW B2)
(SETQ B1NEW (CONS (CAR B1NEW)
(MAPCAR (CDR B1NEW)
EVAL)))
(SETQ B2NEW (CONS (CAR B2NEW)
(MAPCAR (CDR B2NEW)
EVAL)))
(SETQ WHEN:DIFF (DIFFERENCE
(WHEN:VALUE B1NEW)
(WHEN:VALUE B2NEW)))
[COND
[(EQP WHEN:DIFF 0)
(SETQ RESULT1 (A:BEING:ORDER
(CAR B1NEW)
(CAR B2NEW)))
(SETQ
BECAUSE
(APPEND
BECAUSE
(TUPLE
THE WHEN PARTS OF
(@ (CAR B1NEW))
AND
(@ (CAR B2NEW))
ARE EQUAL AND THE FORMER IS
[@ (COND (RESULT1 (QUOTE LESS))
(T (QUOTE MORE]
COMPLEX THAN THE LATTER BEING]
(T
(SETQ RESULT1 (NOT (MINUSP WHEN:DIFF)
))
(SETQ
BECAUSE
(APPEND
BECAUSE
(TUPLE THE WHEN PART OF THE
(@ (CAR B1NEW))
IS
(@ (COND (RESULT1
SUPERIOR)
(T INFERIOR)))
TO THE WHEN PART OF
(@ (CAR B2NEW]
RESULT1)
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK (AND (EQUAL T
(GETP (CAR B1)
BEING))
(EQUAL T
(GETP (CAR B2)
BEING)))
DEMONS NIL
MAIN:EFFECTS NIL
MINOR:EFFECTS NIL
AFFECTS NIL
COMPLEXITY:VECTOR NIL
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL
PREDICATE T)
(PUTPROPS CHOOSE:FROM IDEN [((AND (EQUAL (CAR LI)
CHOOSE:FROM)
(EQUAL (LENGTH LI)
2))
(VECTOR CHOOSE:FROM
(MAPCAR (CADR LI)
(FUNCTION
(LAMBDA (Y)
(TRANSLATE
Y T]
BEING T
IMPLICIT:ARGS (EXP:TEST)
EXPLICIT:ARGS (S)
WHAT (TUPLE CHOOSE THE BEST BEING FROM THE SET
(@ S)
OF BEINGS)
HOW (TUPLE COMPARE FEATURES OF THE ELEMENTS OF
THE SET (@ S)
OF BEINGS)
WHY (TUPLE BECAUSE THE FLOW OF CONTROL OF A
PROGRAM MUST BE DETERMINATE)
SPEC:WHY (QUOTE (NO SPECIAL REASON))
WHEN NIL
META:CODE [PROG
(BEST)
(SETQ BEST (CAR S))
[SETQ
BECAUSE
(VECTOR
WE MUST SELECT THE BEST BEING
FROM
(INVECTOR (MAPCAR S
(QUOTE CAR]
[COND
[(SINGLETON S)
(SETQ
BECAUSE
(APPEND
BECAUSE
(VECTOR AND, TRIVIALLY,
(INVECTOR
(CAR S))
IS OUR ONLY CHOICE]
(T
(MAPC
(CDR S)
(FUNCTION
(LAMBDA
(S1)
(COND
((EQUAL T (BETTER
S1 BEST))
(SETQ BEST S1]
(SETQ BECAUSE
(VECTOR NOW THAT WE HAVE
SELECTED
(CAR BEST)
AS THE BEST BEING OUT
OF THE SET
(MAPCAR S
(QUOTE CAR))
WE MUST CARRY OUT
(INVECTOR BEST)))
(COND ((SETQ TEMPBB (EVAL BEST))
(SET U TEMPBB))
((CDR S)
(CHOOSE:FROM (PULLOUT BEST S]
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK (PROGN
(SETQ EXP:TEST T)
[MAPC
S
(FUNCTION
(LAMBDA
(S1)
(COND
((NOT
(EQUAL
T
(GETP
(CAR
S1)
BEING)))
(SETQ EXP:TEST
NIL]
EXP:TEST)
DEMONS NIL
MAIN:EFFECTS NIL
MINOR:EFFECTS NIL
AFFECTS NIL
COMPLEXITY:VECTOR (.2 .4 .6 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL)
(PUTPROPS CONCEPT:FORMATION BEING T
IDEN (([MEMBER LI (QUOTE ((CONCEPT
FORMATION)
(
CONCEPT:FORMATION)
(CONCEPT
LEARNING)
(FORM CONCEPTS)
(LEARN CONCEPTS)
(LEARNS
CONCEPTS)
(FORMS CONCEPTS]
(VECTOR CONCEPT:FORMATION)))
IMPLICIT:ARGS NIL
EXPLICIT:ARGS NIL
WHAT (TUPLE LEARN HOW TO IMPOSE A CONCEPT
STRUCTURING UPON A DOMAIN;
LEARN HOW TO CHARACTERIZE, OR
AT LEAST DISTINGUISH, VARIOUS
CONCEPTS)
HOW (TUPLE BY CHOOSING THE DESIRED TYPE
OF CONCEPT FORMATION CALLED
FOR, AND THEN CARRYING IT OUT)
WHY (TUPLE CONCEPT:LEARNING IS NECESSARY
TO CONCEPT KNOWLEDGE)
SPEC:WHY (QUOTE (NO SPECIAL REASON))
WHEN [((MEMBER TYPE:OF:C:F ABLE:PUP:LIST)
-70
(TUPLE BECAUSE IF WE CAN ALREADY
DO (@ TYPE:OF:C:F)
THEN WE SHOULDNT TRY TO DO
IT OVER AGAIN))
((MEMBER (QUOTE (CHARACTERIZE
CLASSES))
PUP:WANTS:LIST)
88
(QUOTE (BECAUSE CONCEPT FORMATION
IS A GOOD WAY TO
GET A
CHARACTERIZATION OF
CLASSES)))
(T (COND (NEW:INFO:LIST -60)
(T 40))
(QUOTE (BECAUSE NEW INFORMATION
MIGHT ALTER OUR
COURSE OF ACTION]
META:CODE (EVAL (LIST TYPE:OF:C:F))
COMMENTS NIL
PRE:REQUISITES [(VECTOR AWARE USER
(VECTOR PUP IS
ABOUT TO
WORK ON
CONCEPT
FORMATION))
(VECTOR TYPE OF
CONCEPT:FORMATION IS
TYPE:OF:C:F)
(VECTOR
AWARE USER
(VECTOR THE TYPE OF
CONCEPT
FORMATION PUP
IS ABOUT TO
WORK ON IS
(@ TYPE:OF:C:F]
CO:REQUISITES NIL
POST:REQUISITES ((VECTOR
AWARE USER
(VECTOR PUP HAS
THOUGHT ABOUT
THE
(@ TYPE:OF:C:F)
TYPE OF
CONCEPT:FORMATION)))
EXPLICIT:ARGS:CHECK T
DEMONS (TUPLE INFERENCE:DEMONS
ATTENTION:DEMONS)
MAIN:EFFECTS (((VECTOR ABLE PUP
(VECTOR LEARN
CONCEPTS))
(VECTOR CONCEPT:FORMATION))
)
MINOR:EFFECTS NIL
AFFECTS (TUPLE (TUPLE (EVAL TYPE:OF:C:F)
CALLED))
COMPLEXITY:VECTOR (.1
(PLUS
.2
(TIMES
.8
(DIMENSION2
TYPE:OF:C:F)))
(PLUS
.1
(TIMES
.9
(DIMENSION3
TYPE:OF:C:F)))
.5)
GENERALIZATIONS (ATTEND LEARN
INDUCTIVE:INFERENCE)
SPECIALIZATIONS (VECTOR
(VECTOR ALTERNATIVES
(VECTOR
CLASSIFICATORY:CONCEPT:FORMATION
COMPARITIVE:CONCEPT:FORMATION
METRICAL:CONCEPT:FORMATION)
PARTS
(VECTOR
META:CODE)
CONCEPT:FORMATION)
(VECTOR BOOLEAN
(VECTOR
CONCEPTS MAY
VARY
WITH
TIME)
AFFECTS
(VECTOR THE
BASIC
STRUCTURE OF
FORMING A
CONCEPT)
CONCEPT:FORMATION)
(VECTOR
BOOLEAN
(VECTOR CONCEPT
FORMATION MAY
DEPEND UPON
THE SPEED OF
PRESENTATION OF
THE STIMULI)
AFFECTS
(VECTOR THE AMOUNT OF
EFFORT
(@ TASK:NAME)
SHOULD SPEND
ON TRYING TO
IDENTIFY EACH
STIMULUS)
CONCEPT:FORMATION)
(VECTOR
DICHOTOMY
(VECTOR (VECTOR
INSTANCES
MAY BE LEFT
IN VIEW
INDEFINITELY)
(VECTOR
INSTANCES
MAY BE
REMOVED
AFTER
PROCESSING))
AFFECTED
(VECTOR (VECTOR
NEW
RELATIONS CAN
BE DERIVED
AS NEEDED)
(VECTOR
ALL
RELATIONS
MUST BE
DERIVED
UPON
INITIAL
EXPOSURE TO
THE
STIMULUS))
WHEN
(VECTOR BEFORE
DECIDING
FIRMLY HOW TO
GET RELATIONS
FROM INPUT
STIMULI)
CONCEPT:FORMATION)
(VECTOR
ALTERNATIVES
(VECTOR
CONJUNCTIVE:CONCEPT:FORMATION
DISJUNCTIVE:CONCEPT:FORMATION
MIXED:CONJUNCTIVE:AND:DISJUNCTIVE:CONCEPT:FORMATION)
AFFECTS
(VECTOR HOW
(@ TASK:NAME)
STORES THE
DESCRIPTION OF
A CONCEPT)
PARTS
(VECTOR META:CODE)
CONCEPT:FORMATION)
(VECTOR ALTERNATIVES
(VECTOR
POSITIVE:TRANSFER:CONCEPT:FORMATION
NEGATIVE:TRANSFER:CONCEPT:FORMATION
NO:TRANSFER:CONCEPT:FORMATION
POSITIVE:AND:NEGATIVE:TRANSFER:CONCEPT:FORMATION)
AFFECTS
(VECTOR HOW
PREVIOUSLY:LEARNED
CONCEPTS AND
PREVIOUSLY:ENCOUNTERED
STIMULI
AFFECT THE
LEARNING OF
NEW
CONCEPTS AND
THE
RECOGNITION
THAT A
NEW
CONCEPT IS
NEW)
WHEN
(VECTOR BEFORE
DECIDING
FIRMLY HOW
TO
SEARCH
THROUGH THE
SET OF
CONCEPTS, AND
BEFORE
DECIDING
FIRMLY HOW
TO
INSERT A
NEW
CONCEPT
INTO OUR
SET OF
CONCEPTS)
CONCEPT:FORMATION)
(VECTOR
ALTERNATIVES
(VECTOR
POSITIVE:INSTANCE:UTILIZATION
NEGATIVE:INSTANCE:UTILIZATION
POSITIVE:AND:NEGATIVE:INSTANCE:UTILIZATION)
AFFECTS
(VECTOR WHAT
INFORMATION
(@ TASK:NAME)
MAY USE TO
MODIFY THE
DESCRIPTION OF
A CONCEPT)
PARTS
(VECTOR META:CODE)
CONCEPT:FORMATION)
(VECTOR
BOOLEAN
(VECTOR
SUBJECT:SPECIFIC
BEHAVIOR MAY
BE REQUIRED
OF
(@ TASK:NAME))
AFFECTS
(VECTOR WHETHER
PARAMETERS
DESCRIBING AN
INDIVIDUAL
MUST BE READ
IN BY
(@ TASK:NAME))
WHEN
(VECTOR BEFORE ANY
PROCESSING
ROUTINES ARE
FINALIZED)
WHY
(VECTOR BECAUSE ANY
PROCESSING
ROUTINE MAY
HAVE TO
DEPEND UPON
SOME
INDIVIDUAL
PARAMETERS)
CONCEPT:FORMATION)
(VECTOR
ADAPTATION
(VECTOR DESIRED
DIALOGUE
BETWEEN
(@ TASK:NAME)
AND ITS USERS)
AFFECTS
(VECTOR OUTPUT
VARIABLES, AND
OUTPUT
FORMATS)
CONCEPT:FORMATION))
ALTERNATIVES ((GRAMMATICAL:INFERENCE
PATTERN:RECOGNITION
SIMULATED:EVOLUTION))
LIST (NIL . #7000))
(PUTPROPS DEFER:DECISION BEING T
IDEN [((AND (EQUAL (CAR LI)
DEFER:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR DEFER:DECISION (CADR LI)))
((MATCH (QUOTE (DEFER THE DECISION
ANY1))
LI)
(VECTOR DEFER:DECISION (@ ANY1]
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (D)
EXPLICIT:ARGS:CHECK (MEMBER D
UNDEFERRED:DECISION:LIST)
WHAT (TUPLE DEFER THE DECISION (@ D)
AS LONG AS POSSIBLE)
HOW (TUPLE DECIDE WHEN THE CONSEQUENCES OF
DECISION (@ D)
WOULD NEXT AFFECT OUR WRITING THE
PROGRAM CODE, AND THEN DEMONIZE
THAT SITUATION)
WHY (TUPLE THE LONGER WE CAN DEFER ANY
DECISION, INCLUDING (@ D)
,THE GREATER THE CHANCES THAT WE
WILL HAVE GAINED ENOUGH NEW
KNOWLEDGE OF THE TASK THAT WHEN
WE MUST FINALLY CONSIDER
(@ D)
WE WILL KNOW ENOUGH TO ANSWER IT
EASILY)
SPEC:WHY (QUOTE (NO SPECIAL REASON))
MAIN:EFFECTS [((VECTOR DEFERRED DECISION
ANY1)
(VECTOR DEFER:DECISION
(@ ANY1]
MINOR:EFFECTS NIL
WHEN ((UNDEFERRED:DECISION:LIST
40
(VECTOR BECAUSE THERE EXIST
UNDEFERRED DECISIONS, SO WE
MUST LOOK AFTER THEM IN SOME
WAY BEFORE PROCEDING))
((MEMBER D UNDEFERRED:DECISION:LIST)
89
(VECTOR BECAUSE (@ D)
IS ONE OF THOSE UNDEFERRED
DECISIONS)))
META:CODE [PROGN
(SETQ UNDEFERRED:DECISION:LIST
(PULLOUT D
UNDEFERRED:DECISION:LIST))
[SETQ
SITU
(WHEN:NEXT
(VECTOR PUP REINVESTIGATE
(@ D]
(COND
[(EVAL SITU)
(RESOLVE:DECISION
(VECTOR (@ D)
SINCE
(@ SITU]
((EQUAL SITU (LIST FOREVER))
T)
(T
(SETQ
DEFERRED:DECISION:LIST
(CONS (VECTOR
(@ D)
UNTIL
(@ SITU))
DEFERRED:DECISION:LIST]
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
DEMONS NIL
AFFECTS (QUOTE ((WHEN:NEXT CALLED)))
COMPLEXITY:VECTOR (.5 .5 .5 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL
PREDICATE NIL)
(PUTPROPS EXTRACT:RELEVANT:SUBSET IDEN [((AND (EQUAL (CAR LI)
EXTRACT:RELEVANT:SUBSET)
(EQUAL (LENGTH LI)
2))
(VECTOR
EXTRACT:RELEVANT:SUBSET
(TRANSLATE
(CADR LI)
T]
BEING T
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (NEW:INFO)
WHAT (TUPLE EXTRACT THE SMALL
NUCLEUS OF RELEVANT
INFO FROM (@ NEW:INFO))
HOW (TUPLE BY DELETING ALL THE
IRRELEVANT INFO FROM
(@ NEW:INFO))
WHY (TUPLE ONLY A SMALL AMOUNT OF
INFO IS RELEVANT TO ANY
SPECIFIC PROBLEM, AND
PUP CANNOT HANDLE A
LARGE MASS OF INFO
EFFICIENTLY)
SPEC:WHY (QUOTE (NO SPECIAL REASON))
WHEN [((GREATERP (SIZE NEW:INFO)
50)
70
(QUOTE (BECAUSE IF THE NEW
INFO IS OVER
50 TOKENS
LONG, THEN
WE CANNOT
EFFICIENTLY
COMPREHEND IT))
)
((LESSP (SIZE NEW:INFO)
12)
-80
(QUOTE (BECAUSE IF THE NEW
INFO IS LESS
THAN A DOZEN
TOKENS LONG
THEN WE
SHOULD
EASILY BE
ABLE TO
PROCESS IT
AS IT IS]
META:CODE (PROGN
(
USE:PROGRAMMING:KNOWLEDGE APPLIED TO NEW:INFO SO:AS:TO KEEP
(VECTOR RELEVANT NEW:INFO))
(SETQ
RELEVANT:INFO:LIST
(CONS NEW:INFO
RELEVANT:INFO:LIST)))
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK (MEMBER
NEW:INFO
NEW:INFO:LIST)
DEMONS NIL
MAIN:EFFECTS [((VECTOR RELEVANT
INFO ANY1)
(VECTOR
EXTRACT:RELEVANT:SUBSET
(@ ANY1]
MINOR:EFFECTS NIL
AFFECTS (QUOTE ((
APPLY:PROGRAMMING:KNOWLEDGE CALLED)))
COMPLEXITY:VECTOR (.3 .6 .6 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL)
(PUTPROPS GET:NAME BEING T
IDEN [((AND (EQUAL (CAR LI)
CALL)
(EQUAL (LENGTH LI)
3))
(VECTOR GET:NAME (CADR LI)
(CADDR LI)))
((AND (EQUAL (CAR LI)
NAME)
(EQUAL (LENGTH LI)
3))
(VECTOR GET:NAME (CADR LI)
(CADDR LI]
IMPLICIT:ARGS (TEMP1)
EXPLICIT:ARGS (EXPRESSION NEW:NAME)
WHAT (TUPLE IDENTIFY THE NEW:NAME (@ NEW:NAME)
WITH THE EXPRESSION (@ EXPRESSION))
HOW (TUPLE PUP WILL ASK THE USER WHAT HE WISHES TO
CALL (@ EXPRESSION))
WHY (TUPLE BOTH PUP AND THE USER MAY NEED TO REFER
TO (@ EXPRESSION))
SPEC:WHY (QUOTE (NO SPECIAL REASON))
WHEN [(T (COND ((MEMBER EXPRESSION
NAMED:EXPRESSION:LIST)
-90)
(T 50))
(QUOTE (BECAUSE MOST OBJECTS SHOULD HAVE
NO MORE AND NO LESS THAN
ONE NAME]
META:CODE (PROGN [COND ((ATOM NEW:NAME)
(SET NEW:NAME (READ)))
(T (SET (EVAL NEW:NAME)
(READ]
(SETQ NAMED:EXPRESSION:LIST
(CONS EXPRESSION
NAMED:EXPRESSION:LIST)))
COMMENTS ((SETQ NEW:NAME (CADR NEW:NAME)))
PRE:REQUISITES [(VECTOR PUP STUDIED
(VECTOR PLAUSIBLE NAMES
FOR (@ EXPRESSION))
)
(VECTOR AWARE USER
(VECTOR PUP WANTS USER TO
TYPE IN NAME FOR
(@ EXPRESSION]
CO:REQUISITES NIL
POST:REQUISITES [(VECTOR AWARE USER
(VECTOR PUP AND USER ARE
ABLE TO REFER TO
(@ EXPRESSION)
AS
(@ NEW:NAME)
WHICH IS
(EVAL NEW:NAME]
EXPLICIT:ARGS:CHECK T
DEMONS NIL
MAIN:EFFECTS [((VECTOR ABLE PUP
(VECTOR REFER ANY1 AS ANY2))
(VECTOR GET:NAME (@ ANY1)
(@ ANY2)))
((VECTOR ABLE USER
(VECTOR REFER ANY1 AS ANY2))
(VECTOR GET:NAME (@ ANY1)
(@ ANY2)))
((VECTOR NAMED EXPRESSION ANY1 ANY2)
(VECTOR GET:NAME (@ ANY1)
(@ ANY2]
MINOR:EFFECTS NIL
AFFECTS NIL
COMPLEXITY:VECTOR (.1 .3 .2 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL)
(PUTPROPS GET:NEW:INFORMATION IDEN [((AND (EQUAL (CAR LI)
GET:NEW:INFORMATION)
(EQUAL (LENGTH LI)
2))
(VECTOR GET:NEW:INFORMATION
(CADR LI]
BEING T
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (NEW:INFO)
WHAT (TUPLE GET THE NEW PIECE OF
INFORMATION AND CALL IT
(@ NEW:INFO))
HOW (TUPLE ASK THE USER FOR NEW
INFORMATION)
WHY (TUPLE WE NEED NEW INFORMATION; SEE
ESPECIALLY SPEC:WHY)
SPEC:WHY (QUOTE (NO SPECIAL REASON))
WHEN [(T (COND (NEW:INFO:LIST -68)
(T 50))
(QUOTE (BECAUSE WE SHOULD GET
NEW
INFORMATION IFF
THERE IS NONE
IN EXISTENCE]
META:CODE (PROG1
[COND
[(ATOM NEW:INFO)
(SET NEW:INFO
(INVECTOR (READ]
(T
(SET (EVAL NEW:INFO)
(INVECTOR
(READ]
(SETQ NEW:INFO:LIST
(CONS (EVAL NEW:INFO)
NEW:INFO:LIST))
(SETQ PUP:WANTED:LIST
(CONS (CAR
PUP:WANTS:LIST)
PUP:WANTED:LIST)
)
(SETQ PUP:WANTS:LIST
(CDR PUP:WANTS:LIST)))
COMMENTS NIL
PRE:REQUISITES [(VECTOR
AWARE USER
(APPEND
(QUOTE
(VECTOR PUP WANTS)
)
(CDAR
PUP:WANTS:LIST]
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK T
DEMONS (TUPLE SPECIFICITY:CHECK:DEMON)
MAIN:EFFECTS [((VECTOR NEW INFO ANY1)
(VECTOR
GET:NEW:INFORMATION
(TUPLE QUOTE
ANY1]
MINOR:EFFECTS NIL
AFFECTS NIL
COMPLEXITY:VECTOR (.1 .1 .1 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL)
(PUTPROPS MESSAGE IDEN [((AND (EQUAL (CAR LI)
MESSAGE)
(EQUAL (LENGTH LI)
2))
(VECTOR MESSAGE (CADR LI]
BEING T
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (M)
WHAT (TUPLE GIVE THE USER THE MESSAGE (@ M))
HOW (TUPLE THE USER WILL READ THE MESSAGE
(@ M)
THAT PUP TYPES OUT)
WHY (TUPLE SO THAT THE USER MAY ASSIMILATE THE
INFORMATION IN THE MESSAGE (@ M))
WHEN [((MEMBER M AWARE:USER:LIST)
-201
(QUOTE (BECAUSE THE USER NEVER FORGETS]
META:CODE (PROGN (PRIN1 "PUP: ")
(PRINT (OUTVECTOR M))
(TERPRI)
(SETQ LASTRESPONDER (QUOTE PUP))
(SETQ AWARE:USER:LIST
(CONS M AWARE:USER:LIST))
(SETQ READ:USER:LIST (CONS M
READ:USER:LIST)))
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK T
DEMONS NIL
MAIN:EFFECTS [((VECTOR READ USER ANY1)
(VECTOR MESSAGE (@ ANY1)))
((VECTOR AWARE USER ANY1)
(VECTOR MESSAGE (@ ANY1]
MINOR:EFFECTS ((QUOTE (LASTRESPONDER PUP)))
AFFECTS NIL
COMPLEXITY:VECTOR (0.0 .1 .9 .7)
GENERALIZATIONS (COMMUNICATE I/O)
SPECIALIZATIONS (RESPOND QUERY)
ALTERNATIVES NIL
SPEC:WHY (QUOTE (NO SPECIAL REASON)))
(PUTPROPS OBTAIN:USABLE:INFORMATION IDEN [((AND (EQUAL (CAR LI)
OBTAIN:USABLE:INFORMATION)
(EQUAL (LENGTH LI)
2))
(VECTOR
OBTAIN:USABLE:INFORMATION
(CADR LI]
BEING T
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (U)
WHAT (TUPLE OBTAIN SOME
INFORMATION WHICH CAN
BE USED)
HOW (TUPLE OBTAIN NEW FACTS ABOUT
OLD INFORMATION, OR
OBTAIN TOTALLY NEW
INFORMATION)
WHY (TUPLE PUP HAS NO MORE
INFORMATION THAT IT
CAN USE TO PROGRESS)
SPEC:WHY (QUOTE (NO SPECIAL
REASON))
WHEN NIL
META:CODE [PROGN
(SETQ
BECAUSE
(QUOTE
(VECTOR WE CAN
ONLY TRY
TO OBTAIN
USABLE
INFORMATION IN
ONE WAY
AT A TIME)
))
(CHOOSE:FROM
(QUOTE
((TRANSLATE
U)
(
GET:NEW:INFORMATION U)
(
ANALYZE:IMPLICATIONS U)
(
EXTRACT:RELEVANT:SUBSET U] COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK T
DEMONS NIL
MAIN:EFFECTS [((VECTOR NEW INFO
ANY1)
(VECTOR
OBTAIN:USABLE:INFORMATION
(@ ANY1)))
((VECTOR USABLE
INFO ANY1)
(VECTOR
OBTAIN:USABLE:INFORMATION
(@ ANY1]
MINOR:EFFECTS NIL
AFFECTS (QUOTE ((CHOOSE:FROM
CALLED)
(TRANSLATE
POSSIBLE:CALLED)
(
GET:NEW:INFORMATION POSSIBLE:CALLED)
(
ANALYZE:IMPLICATIONS POSSIBLE:CALLED)
(
EXTRACT:RELEVANT:SUBSET POSSIBLE:CALLED)))
COMPLEXITY:VECTOR (.5 .5 .5 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL)
(PUTPROPS PROPOSE:PLAUSIBLE:NAMES BEING T
IDEN [((AND (EQUAL (CAR LI)
PROPOSE:PLAUSIBLE:NAMES)
(EQUAL (LENGTH LI)
2))
(VECTOR
PROPOSE:PLAUSIBLE:NAMES
(CADR LI)))
((MATCH (QUOTE (PROPOSE
PLAUSIBLE
NAMES FOR
ANY1))
LI)
(VECTOR
PROPOSE:PLAUSIBLE:NAMES
(CADR LI]
IMPLICIT:ARGS (EXPRES2 NEW:EXPRES)
EXPLICIT:ARGS (EXPRES)
EXPLICIT:ARGS:CHECK [COND
((ATOM EXPRES)
(SETQ
NEW:EXPRES
(
COLON:BREAK EXPRES)))
(T
(SETQ
NEW:EXPRES
(PROG
(TEMP1)
[MAPC
EXPRES
(
FUNCTION (LAMBDA (ZZ)
(SETQ TEMP1 (APPEND TEMP1 (COLON:BREAK ZZ]
(RETURN
TEMP1]
WHAT (TUPLE PROPOSE PLAUSIBLE NAMES
FOR (@ EXPRES))
HOW (TUPLE USE PARLOR PSYCHOLOGY TO
EXTRACT MNEMONIC
CONTRACTIONS OF
(@ EXPRES))
WHY (TUPLE AID THE USER OR PUP IN
CHOOSING A EXPRES FOR
THE OBJECT (@ EXPRES))
SPEC:WHY (QUOTE (NO SPECIAL REASON))
MAIN:EFFECTS [((VECTOR
PLAUSIBLE NAMES
(VECTOR FOR ANY1
HAVE BEEN
STUDIED))
(VECTOR
PROPOSE:PLAUSIBLE:NAMES
(@ ANY1)))
((VECTOR
PUP STUDIED
(VECTOR PLAUSIBLE
NAMES FOR
ANY1))
(VECTOR
PROPOSE:PLAUSIBLE:NAMES
(@ ANY1]
MINOR:EFFECTS NIL
WHEN [(T
(COND
((MEMBER
(TUPLE PLAUSIBLE NAMES
FOR
(@ EXPRES))
PUP:STUDIED:LIST)
-99)
(T 33))
(QUOTE (BECAUSE WE SHOULDNT
WASTE TOO
MUCH TIME
GETTING
PLAUSIBLE
NAMES, YET
WE ALSO
SHOULDNT
COMPLETELY LET
THE USER
FEND FOR
HIMSELF ON
THIS
SUBJECT]
META:CODE (PROG
(P)
(SETQ
EXPRES2
(OUTVECTOR
(OUTQUOTE
NEW:EXPRES)))
(SETQ
P
(MAPCAR
[LIST
(INITIALS EXPRES2)
(MAIN:WORDS
EXPRES2)
(FIRST:FEW
(INITIALS
EXPRES2))
(FIRST:FEW
(MAIN:WORDS
EXPRES2))
(FIRST:FEW
(INITIALS
(MAIN:WORDS
EXPRES2)))
(LIST
(PACK
(INITIALS
EXPRES2)))
(LIST
(PACK
(FIRST:FEW
(INITIALS
EXPRES2]
(QUOTE COLON:BACK)))
(SETQ P (SETDIFFERENCE
P KNOWN:NAMES))
(SETQ P (INTERSECTION
P P))
(SETQ
MSG
(VECTOR (@ P)
IS THE SET OF
PLAUSIBLE
NAMES OF
(@ EXPRES2)
WHICH IS AN
EXPANSION OF
(@ EXPRES)))
(SETQ
PLAUSIBLE:NAMES:LIST
(CONS
(VECTOR
FOR
(@ EXPRES)
HAVE BEEN STUDIED)
PLAUSIBLE:NAMES:LIST))
(SETQ
PUP:STUDIED:LIST
(CONS
(VECTOR
PLAUSIBLE NAMES
FOR (@ EXPRES))
PUP:STUDIED:LIST))
(RETURN P))
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES ((VECTOR
AWARE USER
(INVECTOR MSG)))
DEMONS (TUPLE
FRINGE:OF:CONCIOUSNESS:DEMON
PSYCHOLOGY:DEMON)
AFFECTS NIL
COMPLEXITY:VECTOR (.1 .2 .3 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL)
(PUTPROPS REINVESTIGATE:DECISION BEING T
IDEN [((AND (EQUAL (CAR LI)
RESOLVE:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR RESOLVE:DECISION
(CADR LI)))
((MATCH (QUOTE (RESOLVE THE
DECISION
ANY1))
LI)
(VECTOR RESOLVE:DECISION
(VECTOR (VECTOR
BECAUSE OF
DIRECT
COMMAND)
(@ ANY1]
IMPLICIT:ARGS (D1)
EXPLICIT:ARGS (D)
EXPLICIT:ARGS:CHECK (OR
(MEMBER D
DEFERRED:DECISION:LIST)
(EQUAL
(CADDDR
D)
(VECTOR
BECAUSE OF
DIRECT
COMMAND)))
WHAT (VECTOR RESOLVE THE DECISION
(CADR D)
BECAUSE
(CADDDR D)
IS NOW TRUE; FIRST TRY
TO DEFER IT A LITTLE
LONGER)
HOW (VECTOR TRY TO DEFER
(CADDR D)
;ELSE TRY TO RESOLVE IT
WITH PRESENT KNOWLEDGE
;ELSE ASK THE USER TO
RESOLVE IT)
WHY (VECTOR AS FAR AS WE KNOW AT
THIS INSTANT, THE
DECISION (CADDR D)
CANNOT BE DEFERRED ANY
LONGER)
SPEC:WHY (QUOTE (NO SPECIAL REASON))
MAIN:EFFECTS [((VECTOR RESOLVED
DECISION ANY1)
(VECTOR
RESOLVE:DECISION
(VECTOR
(VECTOR BECAUSE
OF DIRECT
COMMAND)
(@ D]
MINOR:EFFECTS NIL
WHEN NIL
META:CODE (PROGN
(SETQ
DEFERRED:DECISION:LIST
(PULLOUT D
DEFERRED:DECISION:LIST))
(SETQ
UNDEFERRED:DECISION:LIST
(CONS (CADR D)
UNDEFERRED:DECISION:LIST))
(DEFER:DECISION
(CADR D)))
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
DEMONS NIL
AFFECTS NIL
COMPLEXITY:VECTOR (.5 .5 .5 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL
PREDICATE NIL)
(PUTPROPS RESOLVE:DECISION BEING T
IDEN [((AND (EQUAL (CAR LI)
RESOLVE:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR RESOLVE:DECISION
(CADR LI)))
((MATCH (QUOTE (RESOLVE THE DECISION
ANY1))
LI)
(VECTOR RESOLVE:DECISION
(VECTOR (VECTOR BECAUSE OF
DIRECT
COMMAND)
(@ ANY1]
IMPLICIT:ARGS (D1)
EXPLICIT:ARGS (D)
EXPLICIT:ARGS:CHECK [OR
(EQUAL (CADDDR
D)
(VECTOR
BECAUSE OF
DIRECT
COMMAND))
(AND
(MEMBER D
DEFERRED:DECISION:LIST)
(EVAL
(CADDDR D]
WHAT (VECTOR RESOLVE THE DECISION
(CADDR D)
BECAUSE
(CADR D)
IS NOW TRUE; FIRST TRY TO
DEFER IT A LITTLE LONGER)
HOW (VECTOR TRY TO DEFER (CADDR D)
;ELSE TRY TO RESOLVE IT WITH
PRESENT KNOWLEDGE ;ELSE ASK
THE USER TO RESOLVE IT)
WHY (VECTOR AS FAR AS WE KNOW AT THIS
INSTANT, THE DECISION
(CADDR D)
CANNOT BE DEFERRED ANY LONGER)
SPEC:WHY (QUOTE (NO SPECIAL REASON))
MAIN:EFFECTS [((VECTOR RESOLVED DECISION
ANY1)
(VECTOR
RESOLVE:DECISION
(VECTOR (VECTOR BECAUSE
OF DIRECT
COMMAND)
(@ D]
MINOR:EFFECTS NIL
WHEN NIL
META:CODE [COND
((MEMBER (CADR D)
RESOLVED:DECISION:LIST)
T)
(T (ASK:USER:ABOUT
(CADR D))
(SETQ
RESOLVED:DECISION:LIST
(CONS (CADR D)
RESOLVED:DECISION:LIST]
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
DEMONS NIL
AFFECTS NIL
COMPLEXITY:VECTOR (.5 .5 .5 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL
PREDICATE NIL)
(PUTPROPS SATISFY IDEN [((AND (EQUAL (CAR LI)
SATISFY)
(EQUAL (LENGTH LI)
2))
(VECTOR SATISFY (TRANSLATE (CADR LI)
T]
IMPLICIT:ARGS (TEMP:LIST)
EXPLICIT:ARGS (G)
WHAT (TUPLE SATISFY THE SIMPLE SUBGOAL
(@ G))
HOW (TUPLE PASS CONTROL TO THE SIMPLEST SUFFICIENT
BEING)
WHY (TUPLE (@ G)
IS A REQUISITE TO BE SATISFIED)
WHEN NIL
META:CODE [COND
([MEMBER
(EVAL (CADDDR G))
(EVAL
(SETQ
TEMP:LIST
(COLON:BACK
(COPY (LIST (CADR G)
(CADDR G)
(QUOTE LIST]
T)
(T
(PROG
(B:LIST)
[MAPC
EFFECTS:TABLE
(FUNCTION
(LAMBDA
(E1)
(COND
((MATCH (CAR E1)
G)
(SETQ
B:LIST
(CONS
(EVAL (CADR E1))
B:LIST]
(SETQ BECAUSE
(VECTOR WE CALL THE SIMPLEST
BEING WHICH CAN BRING
ABOUT THE EFFECT
(@ G)))
(COND
[B:LIST
(RETURN
(PROG
(CB:LIST)
[SETQ
CB:LIST
(COPY
(MAPCAR B:LIST
(QUOTE CDR]
(SORT CB:LIST A:BEING:ORDER)
LABEL5
(SETQ POS:B (CAR CB:LIST))
(EVAL POS:B)
(COND
[(MEMBER
(EVAL (CADDDR G))
(EVAL TEMP:LIST))
(RETURN (SETQ
PUP:SATISFIED:LIST
(CONS G
PUP:SATISFIED:LIST]
((CDR CB:LIST)
(SETQ CB:LIST
(CDR CB:LIST))
(GO LABEL5))
(T NIL]
(T (RETURN NIL]
COMMENTS ((SETQ G (EVAL G)))
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK T
DEMONS NIL
MAIN:EFFECTS [((VECTOR PUP SATISFIED ANY1)
(VECTOR SATISFY (@ ANY1]
MINOR:EFFECTS NIL
AFFECTS [APPEND
[MAPCAR
(PROG
(B:LIST)
[MAPC
EFFECTS:TABLE
(FUNCTION
(LAMBDA
(E1)
(COND
((MATCH (CAR E1)
G)
(SETQ
B:LIST
(CONS (EVAL (CADR E1))
B:LIST]
(RETURN B:LIST))
(FUNCTION
(LAMBDA
(Y)
(COND
(Y (CONS Y (QUOTE (POSSIBLE:CALLED
]
(QUOTE ((TRY:BEING CALLED)
(SORT CALLED)
(A:BEING:ORDER CALLED]
COMPLEXITY:VECTOR (0.0 .3 .2 .4)
GENERALIZATIONS (SERVE)
SPECIALIZATIONS (TRY:BEING)
ALTERNATIVES (WRITE:PROGRAM
ADAPT:PRECONCEIVED:FUNCTION)
BEING T
SPEC:WHY (QUOTE (NO SPECIAL REASON)))
(PUTPROPS SERVE IDEN (((EQUAL LI (QUOTE (SERVE)))
(VECTOR SERVE)))
IMPLICIT:ARGS NIL
EXPLICIT:ARGS NIL
WHAT (TUPLE DO ANYTHING THE USER ASKS)
HOW (TUPLE GET A TASK FROM THE USER)
WHY (TUPLE FUNDAMENTAL DRIVE TO SERVE THE USER)
WHEN NIL
META:CODE (PROG (UNKNOWN:TASK)
(SETQ UNKNOWN:TASK NON:EXECUTABLE)
(SETQ BECAUSE (VECTOR THE CURRENT
TASK
(@ UNKNOWN:TASK)
IS NOT
EXECUTABLE AND
WE HAVE NOTHING
ELSE TO DO AT
THE PRESENT
TIME))
LABEL6
(COND ((NOT (MEMBER UNKNOWN:TASK
EXECUTABLE:INFO:LIST))
(MAPC USER:INTERRUPT:DEMONS
(QUOTE APPLY*))
(OBTAIN:USABLE:INFORMATION
(QUOTE UNKNOWN:TASK))
(GO LABEL6)))
(SETQ ATTEMPTING:SOMETHING:LIST
(CONS UNKNOWN:TASK
ATTEMPTING:SOMETHING:LIST))
(SETQ ATTEMPTING:ANYTHING:LIST
(CONS UNKNOWN:TASK
ATTEMPTING:ANYTHING:LIST))
(SETQ BECAUSE
(VECTOR WE FINALLY HAVE AN
EXECUTABLE TO TASK TO
DO, NAMELY
(@ UNKNOWN:TASK)))
(EVAL (CDR UNKNOWN:TASK)))
COMMENTS ((SETQ PUP:WANTS:LIST (CONS (VECTOR ANY TASK)
PUP:WANTS:LIST)))
PRE:REQUISITES ((VECTOR AWARE USER
(VECTOR PUP WANTS ANY TASK)))
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK T
DEMONS NIL
MAIN:EFFECTS (((VECTOR ATTEMPTING SOMETHING)
(VECTOR SERVE))
((VECTOR ATTEMPTING ANYTHING)
(VECTOR SERVE)))
MINOR:EFFECTS NIL
AFFECTS NIL
COMPLEXITY:VECTOR (.2 .4 .6 .8)
GENERALIZATIONS NIL
SPECIALIZATIONS (WRITE:PROGRAM COUNSEL)
ALTERNATIVES (IGNORE REBEL)
BEING T
SPEC:WHY (QUOTE (NO SPECIAL REASON)))
(PUTPROPS STUDY:TYPE BEING T
IDEN [((MATCH (QUOTE (STUDY:TYPE ANY1))
LI)
(VECTOR STUDY:TYPE (CADR LI]
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (B:CALL)
EXPLICIT:ARGS:CHECK (GETP (CADR B:CALL)
BEING)
WHAT (TUPLE INVESTIGATE THE VARIOUS
SPECIALIZATIONS OF (@ B:CALL))
HOW (TUPLE TRANSFER THE SPECIALIZATIONS
(GETP (CADR B:CALL)
SPECIALIZATIONS)
OF
(@ B:CALL)
ONTO THE LIST OF DECISIONS WHICH MUST
BE ATTENDED TO)
WHY (TUPLE BECAUSE THE MORE SPECIFIC OUR
KNOWLEDGE OF WHAT IS WANTED, THE MORE
EASILY AND COMPLETELY WE MAY SATISFY
THAT REQUEST)
SPEC:WHY (QUOTE (NO SPECIAL REASON))
MAIN:EFFECTS [((VECTOR TYPE OF
(VECTOR ANY1 HAS BEEN
STUDIED))
(VECTOR STUDY:TYPE (@ ANY1)))
((VECTOR PUP STUDIED
(VECTOR TYPE OF ANY1))
(VECTOR STUDY:TYPE (@ ANY1]
MINOR:EFFECTS NIL
WHEN NIL
META:CODE (PROGN
[MAPC
(CDR (GETP (CADR B:CALL)
SPECIALIZATIONS))
(FUNCTION
(LAMBDA
(A)
(COND
((ATOM A)
(SETQ
UNDEFERRED:DECISION:LIST
(CONS A
UNDEFERRED:DECISION:LIST)))
((ATOM (CAR A))
(SETQ
UNDEFERRED:DECISION:LIST
(CONS (EVAL A)
UNDEFERRED:DECISION:LIST)))
(T
(SETQ
UNDEFERRED:DECISION:LIST
(CONS
(APPLY*
(EVAL (CAR A))
B:CALL)
UNDEFERRED:DECISION:LIST]
(SETQ PUP:STUDIED:LIST
(CONS (VECTOR TYPE OF
(@ B:CALL))
PUP:STUDIED:LIST))
(SETQ TYPE:OF:LIST
(CONS (VECTOR (@ B:CALL)
HAS BEEN STUDIED)
TYPE:OF:LIST)))
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
DEMONS NIL
AFFECTS NIL
COMPLEXITY:VECTOR (.5 .5 .5 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL
PREDICATE NIL)
(PUTPROPS TRANSLATE IDEN [((AND (EQUAL (CAR LI)
TRANSLATE T)
(EQUAL (LENGTH LI)
2))
(VECTOR TRANSLATE (CADR LI]
BEING T
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (NEW:INFO FORCE:TRANSLATE)
WHAT (TUPLE TRANSLATE A PIECE OF UNTRANSLATED NEW
INFORMATION)
HOW (TUPLE TRANSFORM (@ NEW:INFO)
INTO MORE EXECUTABLE FORM)
WHY (TUPLE EW INFORMATION (@ NEW:INFO)
IS DECLARATIVE AND MUST BE MADE
PROCEDURAL BEFORE IT MAY BE USED BY
THE SYSTEM)
SPEC:WHY (QUOTE (NO SPECIAL REASON))
WHEN ((T (COND (USABLE:INFO:LIST -60)
(T 50))
(QUOTE (BECAUSE THE ABSENCE OF USABLE
INFORMATION ABDUCTIVELY
CALLS FOR ITS
PRODUCTION; ITS PRESENCE
DEMANDS ITS ASSIMILATION)
))
((MEMBER (EVAL NEW:INFO)
TRANSLATED:INFO:LIST)
-111
(VECTOR BECAUSE WE HAVE ALREADY TRANSLATED
IT IMPLIES WE SHOULDNT NOW)))
META:CODE (PROG
(LI TEMPTR)
(SETQ LI (CDR (EVAL NEW:INFO)))
[MAPC
IDEN:TABLE
(FUNCTION
(LAMBDA
(II)
(COND
((EVAL (CAR II))
[COND
((SETQ
TEMPTR
(EVAL (CADR II)))
(SETQ
TRANSLATED:PAIR:LIST
(CONS
(LIST (EVAL NEW:INFO)
TEMPTR)
TRANSLATED:PAIR:LIST))
(SETQ
TRANSLATED:INFO:LIST
(CONS (EVAL NEW:INFO)
TRANSLATED:INFO:LIST))
(SETQ
EXECUTABLE:INFO:LIST
(CONS TEMPTR
EXECUTABLE:INFO:LIST]
(RETURN TEMPTR]
(PRIN1
"SORRY, I CANNOT TRANSLATE THIS.")
(SETQ NEW:INFO:LIST
(PULLOUT (EVAL NEW:INFO)
NEW:INFO:LIST))
(RETURN NIL))
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK (OR (MEMBER (EVAL NEW:INFO)
NEW:INFO:LIST)
(NULL (EVAL NEW:INFO))
FORCE:TRANSLATE)
DEMONS (TUPLE IDIOM:DEMON)
MAIN:EFFECTS [((VECTOR USABLE INFO
(VECTOR NEW INFO ANY1))
(VECTOR TRANSLATE (@ ANY1)))
((VECTOR TRANSLATED INFO ANY1)
(VECTOR TRANSLATE (@ ANY1]
MINOR:EFFECTS ((VECTOR NEW INFO))
AFFECTS (QUOTE ((LOOKUP CALLED)
(PARSE CALLED)))
COMPLEXITY:VECTOR (.3 .5 .5 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL)
(PUTPROPS WHEN:NEXT BEING T
IDEN [((MATCH (QUOTE (WHEN:NEXT (VECTOR ANY1 ANY2
ANY3)))
LI)
(VECTOR WHEN:NEXT (CADR LI)))
((MATCH (QUOTE (THE NEXT TIME
(VECTOR ANY1 ANY2 ANY3))
)
LI)
(VECTOR WHEN:NEXT (CADDDR LI]
IMPLICIT:ARGS (UTILIZATION UTIL2 AWARE:LIST)
EXPLICIT:ARGS (ACT)
EXPLICIT:ARGS:CHECK (AND
(MEMBER
(CADR ACT)
(QUOTE (USER PUP)))
(EQUAL (LENGTH ACT)
4))
WHAT (TUPLE FIND THE NEXT SITUATION IN WHICH
(CADR ACT)
MUST PERFORM THE OPERATION
(CADDR ACT)
ON
(CADDDR ACT))
HOW (TUPLE EXPLORE THE EFFECTS OF (CADDR ACT)
ING
(CADDDR ACT))
WHY (TUPLE (CADR ACT)
CAN THEN FORGET (CADDDR ACT)
UNTIL THE NEXT SITUATION WE FIND HERE)
SPEC:WHY (QUOTE (NO SPECIAL REASON))
MAIN:EFFECTS [((VECTOR AWARE ANY1 (DELAYABLE
ANY2))
(VECTOR WHEN:NEXT
(VECTOR (@ ANY1)
(CADR ANY2)
(CADDR ANY2]
MINOR:EFFECTS NIL
WHEN NIL
META:CODE (PROGN
[SETQ
RELEVANT:KNOWLEDGE
(COLON:BACK
(COPY (TUPLE (CADR (CADDDR ACT))
(CADR BEING:STACK)
KNOWLEGE]
[SETQ
UTILIZATION
(VECTOR
DELAYABLE
(@ ACT)
UNTIL
(SETQ
UTIL2
(UTILIZE
RELEVANT:KNOWLEDGE
APPLIED:SO:AS:TO:KEEP
(VECTOR
IRRELEVANT
(APPEND
(VECTOR (CADR ACT)
(CADDR ACT))
(CDDAR (CDDDR ACT]
[SETQ
AWARE:LIST
(COLON:BACK
(COPY (LIST (QUOTE AWARE)
(CADR ACT)
(QUOTE LIST]
(SET AWARE:LIST (CONS UTILIZATION
(EVAL
AWARE:LIST)))
UTIL2)
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
DEMONS NIL
AFFECTS NIL
COMPLEXITY:VECTOR (.6 .7 .5 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL
PREDICATE NIL)
(PUTPROPS WRITE:PROGRAM IDEN [((AND (EQUAL (CAR LI)
WRITE:PROGRAM)
(EQUAL (LENGTH LI)
2))
(VECTOR WRITE:PROGRAM
(TRANSLATE (CADR LI)
T)))
((MATCH (QUOTE (WRITE A PROGRAM WHICH
DOES FRAG1))
LI)
(VECTOR WRITE:PROGRAM
(TRANSLATE (INVECTOR FRAG1)
T]
BEING T
IMPLICIT:ARGS (TASK:TYPE TASK:NAME)
EXPLICIT:ARGS (TASK)
WHAT (TUPLE WRITE A PROGRAM WHICH DOES
(@ TASK))
HOW (TUPLE CREATE SPECIALIZED LISP CODE WHICH
WILL DO (@ TASK))
WHY (TUPLE FUNDAMENTAL DRIVE TO OBEY USER;
ALSO, IT IS NECESSARY THAT CODE BE
WRITTEN TO DO (@ TASK)
IN ORDER THAT THE TASK
(@ TASK)
MIGHT BE COMPLETED; ALSO, EXAMINE
SPEC:WHY)
SPEC:WHY (QUOTE (NO SPECIAL REASON))
WHEN [(T (COND ((MEMBER TASK ABLE:PUP:LIST)
-75)
(T 40))
(TUPLE BECAUSE A PRE:EXISTING
ABILITY TO DO (@ TASK)
IMPLIES THAT WRITING A NEW
PROGRAM TO ACCOMPLISH IT IS
SUPERFLUOUS AND, CONVERSELY,
THE INABILITY TO DO
(@ TASK)
ABDUCTIVELY ENCOURAGES US
THAT WE ARE ON THE RIGHT
TRACK))
((MEMBER TASK WRITTEN:PROGRAMS:LIST)
-80
(QUOTE (BECAUSE WE ARE NOT AFTER MUCH
EFFICIENCY, AND IF A
PROGRAM ALREADY
EXISTS, THEN WE SHOULD
USE IT)))
((MEMBER (TUPLE PUP IS ABOUT TO WRITE A
PROGRAM TO DO
(@ TASK))
AWARE:USER:LIST)
70
(QUOTE (BECAUSE WE GO BY THE OLD
ENGLISH LEGAL RULE,
THAT SILENCE SIGNIFIES
APPROVAL)))
(T (COND (NEW:INFO:LIST -120)
(T 40))
(QUOTE (BECAUSE WE SHOULD USE UP THE
NEW INFORMATION
BEFORE WRITING
PROGRAMS ALSO:
BECAUSE IF NO NEW
INFO IS PRESENT,
THEN WE NEEDN'T FEEL
GUILTY ABOUT
STARTING TO WRITE A
PROGRAM]
META:CODE [PROG
(DONE PGM)
(SETQ PGM (VECTOR))
(SETQ UNDEFINED:SECTION:LIST
(CONS (VECTOR (@ TASK)
NAME
(@ TASK:NAME))
UNDEFINED:SECTION:LIST))
LABEL4
(COND
((MEMBER TASK:NAME
WRITTEN:PROGRAMS:LIST)
(SETQ WRITTEN:PROGRAMS:LIST
(CONS TASK
WRITTEN:PROGRAMS:LIST))
(SETQ ABLE:PUP:LIST
(CONS TASK ABLE:PUP:LIST)
)
(SETQ ABLE:USER:LIST
(CONS TASK
ABLE:USER:LIST))
(RETURN T))
((MEMBER NIL
(MAPCAR (APPEND
USER:INTERRUPT:DEMONS
CURRENT:DEMONS)
(QUOTE APPLY*))
)
[CHOOSE:FROM
(QUOTE ((
OBTAIN:USABLE:INFORMATION PGM)
(USE:INFORMATION
PGM)
(
FILL:IN:UNDEFINED:SECTION PGM)
(
CLARIFY:IMPROBABLE:SITUATION PGM)
(
ADAPT:PRECONCEIVED:FUNCTION PGM)
(FIX:INCORRECT:PIECE
PGM]
(GO LABEL4))
(T (RETURN NIL]
COMMENTS NIL
PRE:REQUISITES ((VECTOR AWARE USER
(VECTOR PUP IS ABOUT
TO WRITE A
PROGRAM TO DO
(@ TASK)))
(VECTOR NAMED EXPRESSION
(@ TASK)
(VECTOR TASK:NAME))
(VECTOR AWARE USER
(VECTOR THE NAME OF
THE PROGRAM
TO DO
(@ TASK)
IS
(@ TASK:NAME))
)
(VECTOR TYPE OF
(VECTOR (@ TASK)
HAS BEEN
STUDIED)))
CO:REQUISITES NIL
POST:REQUISITES ((VECTOR AWARE USER
(VECTOR
THE PROGRAM
(@ TASK:NAME)
TO DO
(@ TASK)
IS COMPLETE)))
EXPLICIT:ARGS:CHECK T
DEMONS (TUPLE PROGRAM:WRITING:DEMONS
DEFERRAL:DEMON
REINVESTIGATION:DEMON)
MAIN:EFFECTS [((VECTOR ABLE PUP ANY1)
(VECTOR WRITE:PROGRAM
(@ ANY1)))
((VECTOR WRITTEN PROGRAMS ANY1)
(VECTOR WRITE:PROGRAM
(@ ANY1)))
((VECTOR ABLE USER ANY1)
(VECTOR WRITE:PROGRAM
(@ ANY1]
MINOR:EFFECTS NIL
AFFECTS (QUOTE ((OBTAIN:USABLE:INFORMATION
POSSIBLE:CALLED)
(USE:INFORMATION
POSSIBLE:CALLED)
(FILL:IN:UNDEFINED:SECTION
POSSIBLE:CALLED)
(CLARIFY:IMPROBABLE:SITUATION
POSSIBLE:CALLED)
(ADAPT:PRECONCEIVED:FUNCTION
POSSIBLE:CALLED)))
COMPLEXITY:VECTOR ((PLUS .3
(TIMES .6
(DIMENSION1
TASK:TYPE)))
.9 .7 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL)
[MAPC (APPEND PUP5FNS SET:OF:BEINGS SET:OF:BEING:PARTS)
(FUNCTION (LAMBDA (V)
(SET V V]
(MAPC SET:OF:BEINGS SEMI:COMPILE)
(PRIN1
" MINI PUP FILE: USE FAD OR AD OR MAKEFILE FOR NEW VERSION ")
STOP